trackler 2.0.6.1 → 2.0.6.2

data/tracks/ruby/exercises/all-your-base/example.tt

@@ -0,0 +1,17 @@
+require 'minitest/autorun'
+require_relative 'all_your_base'
+
+# Test data version: <%= sha1 %>
+class AllYourBaseTest < Minitest::Test<% test_cases.each do |test_case| %>
+  def <%= test_case.test_name %>
+    <%= test_case.skipped %>
+<%= test_case.workload %>
+  end
+<% end %>
+
+<%= IO.read(XRUBY_LIB + '/bookkeeping.md') %>
+  def test_bookkeeping
+    skip
+    assert_equal <%= version.next %>, BookKeeping::VERSION
+  end
+end

data/tracks/ruby/lib/all_your_base_cases.rb

@@ -0,0 +1,109 @@
+class AllYourBaseCase < OpenStruct
+  def test_name
+    'test_%s' % description.downcase.tr(' -', '_')
+  end
+
+  def workload
+    indent(4, (assignments + assertion).join("\n")) + "\n"
+  end
+
+  def skipped
+    index.zero? ? '# skip' : 'skip'
+  end
+
+  private
+
+  def indent(size, text)
+    text.lines.each_with_object('') do |line, obj|
+      obj << (line == "\n" ? line : ' ' * size + line)
+    end
+  end
+
+  def assignments
+      [
+        "digits = #{input_digits}",
+        "input_base = #{input_base}",
+        "output_base = #{output_base}",
+      ]
+  end
+
+  def assertion
+    return error_assertion unless expected
+
+    [
+      "expected = #{expected}",
+      "",
+      "converted = BaseConverter.convert(input_base, digits, output_base)",
+      "",
+      "assert_equal expected, converted,",
+      indent(13, error_message),
+    ]
+  end
+
+  def error_assertion
+    [
+      "",
+      "assert_raises ArgumentError do",
+      "  BaseConverter.convert(input_base, digits, output_base)",
+      "end",
+    ]
+  end
+
+  def error_message
+    %q("Input base: #{input_base}, output base #{output_base}. " \\) \
+      "\n" + %q("Expected #{expected} but got #{converted}.")
+  end
+end
+
+class AllYourBaseCase::PreProcessor
+  class << self
+    attr_reader :row
+
+    def call(row)
+      @row = row
+
+      row.merge('expected' => expected_value)
+    end
+
+    private :row
+    private
+
+    def expected_value
+      return row['expected'] if row['expected']
+
+      if invalid_input_digits? || invalid_bases?
+        nil
+      elsif row['input_digits'].empty?
+        []
+      elsif input_of_zero?
+        [0]
+      else
+        handle_special_cases
+      end
+    end
+
+    def invalid_input_digits?
+      row['input_digits'].any? { |x| x < 0 || x >= row['input_base'] }
+    end
+
+    def invalid_bases?
+      row['input_base'] <= 1 || row['output_base'] <= 1
+    end
+
+    def input_of_zero?
+      row['input_digits'].all? { |x| x == 0 }
+    end
+
+    def handle_special_cases
+      [4,2] if row['input_digits'] == [0, 6, 0]
+    end
+  end
+end
+
+AllYourBaseCases = proc do |data|
+  JSON.parse(data)['cases'].map.with_index do |row, i|
+    AllYourBaseCase.new(
+      AllYourBaseCase::PreProcessor.call(row).merge(index: i),
+    )
+  end
+end

data/tracks/ruby/lib/generator.rb

@@ -1,109 +1,30 @@
-#!/usr/bin/env ruby
-
-require 'erb'
-require 'json'
-require 'ostruct'
-
-# Wrap git shell commands.
-class GitCommand
-  def self.short_sha(base_path)
-    git_path = File.join(base_path, '.git')
-    `git --git-dir=#{git_path} log -1 --pretty=format:'%h'`
-  end
-end
-
-class Generator
-  METADATA_REPOSITORY = 'x-common'.freeze
-
-  attr_reader :name, :cases
-  def initialize(name, cases, metadata_repository_path = nil, xruby_root = nil)
-    @name = name
-    @cases = cases
-    @metadata_repository_path = metadata_repository_path || default_metadata_path
-    @xruby_root = xruby_root || '.'
-  end
-
-  def default_metadata_path
-    File.join('..', METADATA_REPOSITORY)
-  end
-
-  def metadata_dir
-    File.join(@metadata_repository_path, 'exercises', name)
-  end
-
-  def exercise_dir
-    File.join(@xruby_root, 'exercises', name)
-  end
-
-  def exercise_meta_dir
-    File.join(exercise_dir, '.meta')
-  end
-
-  def version_filename
-    File.join(exercise_meta_dir, '.version')
-  end
-
-  def data
-    File.read(File.join(metadata_dir, 'canonical-data.json'))
-  end
-
-  def path_to(file)
-    File.join(exercise_dir, file)
-  end
-
-  def version
-    @version ||= File.read(version_filename).strip.to_i
-  end
-
-  def sha1
-    GitCommand.short_sha(@metadata_repository_path)
-  end
-
-  def test_cases
-    cases.call(data)
-  end
-
-  def metadata_repository_missing_message
-    <<-EOM.gsub(/^ {6}/, '')
-
-      '#{METADATA_REPOSITORY}' repository not found.
-      Try running the command:
-        git clone https://github.com/exercism/#{METADATA_REPOSITORY}.git "#{metadata_dir}"
-
-    EOM
-  end
-
-  def generate
-    check_metadata_repository_exists
-    generate_test_file
-    increment_version
-    increment_version_in_example
-  end
-
-  def check_metadata_repository_exists
-    unless File.directory?(metadata_dir)
-      $stderr.puts metadata_repository_missing_message
-      fail Errno::ENOENT.new(metadata_dir)
-    end
-  end
-
-  def generate_test_file
-    File.open(path_to("#{name.gsub(/[ -]/, '_')}_test.rb"), 'w') do |f|
-      template = File.read(path_to('example.tt'))
-      f.write ERB.new(template, nil, '<>').result binding
+require 'require_all'
+require_rel 'generator' # Include everything in the 'generator' subdirectory
+
+module Generator
+  # Immutable value object for storing paths
+  class Paths
+    attr_reader :track, :metadata
+    def initialize(track:, metadata:)
+      @track = track
+      @metadata = metadata
     end
   end
 
-  def increment_version
-    File.open(version_filename, 'w') do |f|
-      f.write version + 1
+  # This contains the order for updating/generating the files. (Strategy pattern).
+  # Doesn't update the version information.
+  class GenerateTests < RepositoryDelegator
+    def call
+      create_tests_file
     end
   end
 
-  def increment_version_in_example
-    contents = File.read(path_to('example.rb'))
-    File.open(path_to('example.rb'), 'w') do |f|
-      f.write contents.gsub("VERSION = #{version}", "VERSION = #{version + 1}")
+  # Update everything.
+  class UpdateVersionAndGenerateTests < RepositoryDelegator
+    def call
+      update_tests_version
+      update_example_solution
+      create_tests_file
     end
   end
 end

data/tracks/ruby/lib/generator/command_line.rb

@@ -0,0 +1,119 @@
+require 'logger'
+require 'optparse'
+
+module Generator
+  # Processes the command line arguments and sets everthing up and returns a
+  # generator that can be called
+  class CommandLine
+    def initialize(paths)
+      @paths = paths
+      @options = default_options
+    end
+
+    def parse(args)
+      parse_options(args)
+      generator if valid?
+    end
+
+    private
+
+    def valid?
+      validate_paths && validate_options && validate_exercise && validate_cases
+    end
+
+    def generator
+      generator_class.new(repository)
+    end
+
+    def generator_class
+      @options[:freeze] ? GenerateTests : UpdateVersionAndGenerateTests
+    end
+
+    def repository
+      if @options[:verbose]
+        LoggingRepository.new(paths: @paths, exercise_name: @options[:exercise_name], logger: logger)
+      else
+        Repository.new(paths: @paths, exercise_name: @options[:exercise_name])
+      end
+    end
+
+    def parse_options(args)
+      args = args.dup
+      option_parser.parse!(args)
+      @options[:exercise_name] = args.shift
+    end
+
+    def logger
+      logger = Logger.new($stdout)
+      logger.formatter = proc { |_severity, _datetime, _progname, msg| "#{msg}\n" }
+      logger.level = @options[:verbose] ? Logger::DEBUG : Logger::ERROR
+      logger
+    end
+
+    def default_options
+      {
+        freeze: false,
+        verbose: false,
+        exercise_name: nil
+      }
+    end
+
+    def validate_options
+      return true unless @options[:help]
+      $stdout.puts usage
+      false
+    end
+
+    def validate_paths
+      validate_metadata_repository
+    end
+
+    def validate_exercise
+      return true if @options[:exercise_name]
+      $stderr.puts "Exercise name required!\n"
+      $stdout.puts usage
+      false
+    end
+
+    def validate_cases
+      return true if available_generators.include?(@options[:exercise_name])
+      $stderr.puts "A generator does not currently exist for #{@options[:exercise_name]}!"
+      false
+    end
+
+    def available_generators
+      Files::GeneratorCases.available(@paths.track)
+    end
+
+    def option_parser
+      @option_parser ||= OptionParser.new do |parser|
+        parser.banner = "Usage: #{$PROGRAM_NAME} [options] exercise-generator"
+        parser.on('-f', '--freeze', 'Don\'t update test version') { |value| @options[:freeze] = value }
+        parser.on('-h', '--help', 'Displays this help message') { |value| @options[:help] = value }
+        parser.on('-v', '--verbose', 'Display progress messages') { |value| @options[:verbose] = value }
+      end
+    end
+
+    def usage
+      option_parser.help <<
+        "\nAvailable exercise generators:\n" <<
+        available_generators.sort.join(' ')
+    end
+
+    def validate_metadata_repository
+      return true if File.directory?(@paths.metadata)
+      $stderr.puts metadata_repository_missing_message(@paths.metadata)
+      false
+    end
+
+    def metadata_repository_missing_message(repository)
+      <<-EOM.gsub(/^ {6}/, '')
+
+      'x-common' repository not found.
+      Try running the command:
+        git clone https://github.com/exercism/x-common.git "#{repository}"
+
+      EOM
+    end
+  end
+end

data/tracks/ruby/lib/generator/files.rb

@@ -0,0 +1,58 @@
+require 'pathname'
+
+module Generator
+  module Files
+    class Readable
+      attr_reader :filename, :repository_root
+      def initialize(filename:,repository_root: nil)
+        @filename = filename
+        @repository_root = repository_root
+      end
+
+      def to_s
+        File.read(filename) if File.exist?(filename)
+      end
+
+      def abbreviated_commit_hash
+        GitCommand.abbreviated_commit_hash(git_path, relative_filename)
+      end
+
+      private
+
+      def relative_filename
+        Pathname.new(filename).relative_path_from(Pathname.new(repository_root)).to_s
+      end
+
+      def git_path
+        File.join(repository_root, '.git')
+      end
+    end
+
+    class Writable < Readable
+      def save(content)
+        write(content) unless content == to_s
+        content
+      end
+
+      private
+
+      def write(content)
+        File.open(filename, 'w') do |file|
+          file.write content
+        end
+      end
+    end
+
+    # An Exercise is used as part of a Repository
+    # so expects :paths and :exercise_name to be defined.
+    module Exercise
+      def paths
+        fail NotImplementedError, 'Should return a Generator::Paths object'
+      end
+
+      def exercise_name
+        fail NotImplementedError, 'Should return a String object'
+      end
+    end
+  end
+end

data/tracks/ruby/lib/generator/files/metadata_files.rb

@@ -0,0 +1,22 @@
+module Generator
+  module Files
+    module MetadataFiles
+      include Exercise
+
+      def canonical_data
+        CanonicalDataFile.new(
+          filename: File.join(exercise_metadata_path, 'canonical-data.json'),
+          repository_root: paths.metadata)
+      end
+
+      private
+
+      def exercise_metadata_path
+        File.join(paths.metadata, 'exercises', exercise_name)
+      end
+    end
+
+    class CanonicalDataFile < Readable
+    end
+  end
+end