trackler 2.0.6.1 → 2.0.6.2

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

@@ -0,0 +1,83 @@
+require 'erb'
+
+module Generator
+  module Files
+    module GeneratorCases
+      module_function
+
+      def available(track_path)
+        generator_glob = File.join(track_path, 'lib', '*_cases.rb')
+        Dir[generator_glob].sort.map { |filename| exercise_name(filename) }
+      end
+
+      def filename(exercise_name)
+        "#{exercise_name.tr('-','_')}_cases"
+      end
+
+      def proc_name(exercise_name)
+        filename(exercise_name).split('_').map(&:capitalize).join
+      end
+
+      def exercise_name(filename)
+        %r{([^/]*)_cases\.rb$}.match(filename).captures[0].tr('_','-')
+      end
+    end
+
+    module TrackFiles
+      include Exercise
+
+      def tests_version
+        TestsVersionFile.new(filename: File.join(exercise_path, '.meta', '.version'))
+      end
+
+      def example_solution
+        ExampleSolutionFile.new(filename: File.join(exercise_path, 'example.rb'))
+      end
+
+      def minitest_tests
+        MinitestTestsFile.new(filename: File.join(exercise_path, minitest_tests_filename))
+      end
+
+      def tests_template
+        TestsTemplateFile.new(filename: File.join(exercise_path, 'example.tt'))
+      end
+
+      private
+
+      def exercise_path
+        File.join(paths.track, 'exercises', exercise_name)
+      end
+
+      def minitest_tests_filename
+        "#{exercise_name.gsub(/[ -]/, '_')}_test.rb"
+      end
+    end
+
+    class TestsVersionFile < Writable
+      def to_i
+        to_s.to_i
+      end
+
+      def increment
+        save(to_i + 1)
+      end
+    end
+
+    class ExampleSolutionFile < Writable
+      def update_version(version)
+        content = to_s.gsub(/VERSION = \d+/, "VERSION = #{version}")
+        save(content)
+      end
+    end
+
+    class MinitestTestsFile < Writable
+      def generate(template:,values:)
+        content = ERB.new(template, nil, '<>').result values.get_binding
+        save(content)
+      end
+    end
+
+    class TestsTemplateFile < Readable
+    end
+  end
+end

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

@@ -0,0 +1,8 @@
+module Generator
+  # Wrap git shell commands.
+  class GitCommand
+    def self.abbreviated_commit_hash(git_path, repository_relative_path)
+      `git --git-dir=#{git_path} log -1 --pretty=format:'%h' -- #{repository_relative_path}`
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+require 'delegate'
+
+module Generator
+  class Repository
+    include Files::TrackFiles
+    include Files::MetadataFiles
+    include TemplateValuesFactory
+
+    def initialize(paths:, exercise_name:)
+      @paths = paths
+      @exercise_name = exercise_name
+    end
+
+    attr_reader :paths, :exercise_name
+
+    def version
+      tests_version.to_i
+    end
+
+    def update_tests_version
+      tests_version.increment
+    end
+
+    def update_example_solution
+      example_solution.update_version(version)
+    end
+
+    def create_tests_file
+      minitest_tests.generate(
+        template: tests_template.to_s,
+        values: template_values
+      )
+    end
+  end
+
+  # A repository that also logs its progress.
+  class LoggingRepository < Repository
+    def initialize(paths:, exercise_name:, logger:)
+      super(paths: paths, exercise_name: exercise_name)
+      @logger = logger
+    end
+
+    def update_tests_version
+      super
+      @logger.info "Incremented tests version to #{version}"
+    end
+
+    def update_example_solution
+      super
+      @logger.info "Updated version in example solution to #{version}"
+    end
+
+    def create_tests_file
+      super
+      @logger.info "Generated tests for #{exercise_name}"
+    end
+  end
+
+  # This exists to give us a clue as to what we are delegating to.
+  class RepositoryDelegator < SimpleDelegator
+  end
+end

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

@@ -0,0 +1,47 @@
+module Generator
+  # Contains methods accessible to the ERB template
+  class TemplateValues
+    attr_reader :sha1, :version, :test_cases
+
+    def initialize(sha1:, version:, test_cases:)
+      @sha1 = sha1
+      @version = version
+      @test_cases = test_cases
+    end
+
+    def get_binding
+      binding
+    end
+  end
+
+  module TemplateValuesFactory
+    def template_values
+      # These are needed by the 'ExerciseCases' classes
+      # TODO: move these into the individual classes
+      require 'ostruct'
+      require 'json'
+      require cases_require_name
+
+      # Compensate for the version.next that appears in template files.
+      # TODO: remove the .next from the template files and remove compensation
+      compensated_version = version - 1
+
+      TemplateValues.new(
+        # TODO: rename sha1 to abbreviated_commit_hash
+        sha1: canonical_data.abbreviated_commit_hash,
+        version: compensated_version,
+        test_cases: test_cases_proc.call(canonical_data.to_s)
+      )
+    end
+
+    private
+
+    def cases_require_name
+      Files::GeneratorCases.filename(exercise_name)
+    end
+
+    def test_cases_proc
+      Object.const_get(Files::GeneratorCases.proc_name(exercise_name))
+    end
+  end
+end

data/tracks/ruby/lib/helper.rb

@@ -1,2 +1,5 @@
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-XRUBY_LIB = File.dirname(__FILE__).freeze
+XRUBY_ROOT = File.join(File.dirname(__FILE__), '..').freeze
+XRUBY_LIB = File.join(XRUBY_ROOT, 'lib').freeze
+METADATA_REPOSITORY_PATH = File.join(XRUBY_ROOT, '..', 'x-common').freeze
+
+$LOAD_PATH.unshift(XRUBY_LIB)

data/tracks/ruby/test/fixtures/metadata/exercises/alpha/canonical-data.json

@@ -1,11 +1,10 @@
 {
-    "solve": {
-        "description": "Test canonical data",
-        "cases": [
-            {
-                "description": "add 2 numbers",
-                "input": [1,1],
-                "expected": 2
-            },
-    }
+	"description": "Test canonical data",
+	"cases": [
+	{
+		"description": "add 2 numbers",
+		"input": [1,1],
+		"expected": 2
+	}
+	]
 }

data/tracks/ruby/test/fixtures/xruby/exercises/alpha/example.tt

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+require 'minitest/autorun'
+require_relative 'alpha'
+
+# Common test data version: <%= sha1 %>
+class AlphaTest < Minitest::Test<% test_cases.each do |test_case| %>
+  def <%= test_case.name %>
+    <%= test_case.skip %>
+    string = '<%= test_case.input %>'
+    <%= test_case.assertion %> Alpha.something?(string)
+  end
+<% end %>
+<%= IO.read(XRUBY_LIB + '/bookkeeping.md') %>
+  def test_bookkeeping
+    skip
+    assert_equal <%= version.next %>, BookKeeping::VERSION
+  end
+end

data/tracks/ruby/test/fixtures/xruby/lib/alpha_cases.rb

@@ -0,0 +1,20 @@
+class AlphaCase < OpenStruct
+
+  def name
+    format('test_%s', description.downcase.gsub(/[ -]/,'_'))
+  end
+
+  def assertion
+    expected ? 'assert' : 'refute'
+  end
+
+  def skip
+    index.zero? ? '# skip' : 'skip'
+  end
+end
+
+AlphaCases = proc do |data|
+  JSON.parse(data)['cases'].map.with_index do |row, i|
+    AlphaCase.new(row.merge('index' => i))
+  end
+end

data/tracks/ruby/test/generator/command_line_test.rb

@@ -0,0 +1,83 @@
+require_relative '../test_helper'
+
+module Generator
+  class CommandLineTest < Minitest::Test
+    FixturePaths = Paths.new(
+      metadata: 'test/fixtures/metadata',
+      track: 'test/fixtures/xruby'
+    )
+
+    def test_parse
+      expected_stderr = 'Exercise name required'
+      assert_output(/Usage:/, /#{expected_stderr}/) do
+        refute CommandLine.new(FixturePaths).parse([])
+      end
+    end
+
+    def test_invalid_metadata_repository_outputs_message_to_stderr
+      paths = Paths.new(metadata: 'test/fixtures/nonexistent', track: nil)
+      expected_stderr = <<-MESSAGE.gsub(/^ {6}/,'')
+      'x-common' repository not found.
+      Try running the command:
+        git clone https://github.com/exercism/x-common.git "test/fixtures/nonexistent"
+      MESSAGE
+      assert_output nil, /#{expected_stderr}/ do
+        refute CommandLine.new(paths).parse([])
+      end
+    end
+
+    def test_usage_help
+      args = %w(-h)
+      assert_output(/Usage:/, nil) do
+        refute CommandLine.new(FixturePaths).parse(args)
+      end
+    end
+
+    def test_usage_help_with_exercise
+      args = %w(-h beta)
+      assert_output(/Usage:/, nil) do
+        refute CommandLine.new(FixturePaths).parse(args)
+      end
+    end
+
+    def test_usage_help_includes_available_generators
+      args = %w(-h)
+      fake_generators = %w(some fake generator names also-hyphen-ated)
+      Files::GeneratorCases.stub :available, fake_generators do
+        assert_output(/#{fake_generators.sort.join(' ')}/, nil) do
+          refute CommandLine.new(FixturePaths).parse(args)
+        end
+      end
+    end
+
+    def test_validate_missing_generator
+      args = %w(nonexistent)
+      Files::GeneratorCases.stub :available, [] do
+        assert_output(nil, /A generator does not currently exist fo/) do
+          refute CommandLine.new(FixturePaths).parse(args)
+        end
+      end
+    end
+
+    def test_default_options
+      args = %w(beta)
+      Files::GeneratorCases.stub :available, %w(beta) do
+        assert_instance_of UpdateVersionAndGenerateTests, CommandLine.new(FixturePaths).parse(args)
+      end
+    end
+
+    def test_frozen_option
+      args = %w(-f beta)
+      Files::GeneratorCases.stub :available, %w(beta) do
+        assert_instance_of GenerateTests, CommandLine.new(FixturePaths).parse(args)
+      end
+    end
+
+    def test_verbose_option
+      args = %w(-v beta)
+      Files::GeneratorCases.stub :available, %w(beta) do
+        assert_instance_of UpdateVersionAndGenerateTests, CommandLine.new(FixturePaths).parse(args)
+      end
+    end
+  end
+end

data/tracks/ruby/test/generator/files/metadata_files_test.rb

@@ -0,0 +1,25 @@
+require_relative '../../test_helper.rb'
+module Generator
+  module Files
+    class MetadataFilesTest < Minitest::Test
+      FixturePaths = Paths.new(
+        metadata: 'test/fixtures/metadata',
+        track: 'test/fixtures/xruby'
+      )
+
+      class TestMetadataFiles
+        def initialize
+          @paths = FixturePaths
+          @exercise_name = 'alpha'
+        end
+        attr_reader :paths, :exercise_name
+        include MetadataFiles
+      end
+
+      def test_canonical_data
+        subject = TestMetadataFiles.new
+        assert_instance_of CanonicalDataFile, subject.canonical_data
+      end
+    end
+  end
+end

data/tracks/ruby/test/generator/files/track_files_test.rb

@@ -0,0 +1,117 @@
+require_relative '../../test_helper.rb'
+
+module Generator
+  module Files
+    class GeneratorCasesTest < Minitest::Test
+      def test_no_cases_found
+        track_path = 'test/fixtures/nonexistant'
+        assert_equal [], GeneratorCases.available(track_path)
+      end
+
+      def test_cases_found
+        track_path = 'test/fixtures/xruby'
+        assert_equal %w(alpha beta), GeneratorCases.available(track_path).sort
+      end
+
+      def test_available_returns_exercise_names
+        track_path = 'test/fixtures/xruby'
+        Dir.stub :[], %w(/alpha_cases.rb hy_phen_ated_cases.rb) do
+          assert_equal %w(alpha hy-phen-ated), GeneratorCases.available(track_path)
+        end
+      end
+
+      def test_filename
+        exercise_name = 'two-parter'
+        assert_equal 'two_parter_cases', GeneratorCases.filename(exercise_name)
+      end
+
+      def test_proc_name
+        exercise_name = 'two-parter'
+        assert_equal 'TwoParterCases', GeneratorCases.proc_name(exercise_name)
+      end
+    end
+
+    class TrackFilesTest < Minitest::Test
+      FixturePaths = Paths.new(
+        metadata: 'test/fixtures/metadata',
+        track: 'test/fixtures/xruby'
+      )
+
+      class TestTrackFiles
+        def initialize
+          @paths = FixturePaths
+          @exercise_name = 'alpha'
+        end
+        attr_reader :paths, :exercise_name
+        include TrackFiles
+      end
+
+      def test_tests_version
+        subject = TestTrackFiles.new
+        assert_instance_of TestsVersionFile, subject.tests_version
+      end
+
+      def test_example_solution
+        subject = TestTrackFiles.new
+        assert_instance_of ExampleSolutionFile, subject.example_solution
+      end
+
+      def test_minitest_tests
+        subject = TestTrackFiles.new
+        assert_instance_of MinitestTestsFile, subject.minitest_tests
+      end
+
+      def test_tests_template
+        subject = TestTrackFiles.new
+        assert_instance_of TestsTemplateFile, subject.tests_template
+      end
+    end
+
+    class TestsVersionFileTest < Minitest::Test
+      class TestTestsVersionFile < TestsVersionFile
+        def save(content)
+          content
+        end
+      end
+
+      def test_increment
+        subject = TestTestsVersionFile.new(filename: 'test/fixtures/xruby/exercises/alpha/.meta/.version')
+        assert_equal 2, subject.increment
+      end
+    end
+
+    class ExampleSolutionFileTest < Minitest::Test
+      class TestExampleSolutionFile < ExampleSolutionFile
+        def save(content)
+          content
+        end
+      end
+
+      def test_update_version
+        subject = TestExampleSolutionFile.new(filename: 'test/fixtures/xruby/exercises/alpha/example.rb')
+        assert_match(/VERSION = 2/, subject.update_version(2))
+      end
+    end
+
+    class MinitestTestsFileTest < Minitest::Test
+      class TestMinitestTestsFile < MinitestTestsFile
+        def save(content)
+          content
+        end
+      end
+
+      def test_update_version
+        mock_template = Minitest::Mock.new
+        mock_values = Minitest::Mock.new
+        mock_values.expect :get_binding, 'mock binding'
+        mock_erb = Minitest::Mock.new
+        mock_erb.expect :result, 'new content', ['mock binding']
+
+        subject = TestMinitestTestsFile.new(filename: 'test/fixtures/xruby/exercises/alpha/alpha_tests.rb')
+        ERB.stub :new, mock_erb do
+          assert_equal 'new content', subject.generate(template: mock_template, values: mock_values)
+        end
+      end
+    end
+  end
+end