app_archetype 1.2.3

data/spec/app_archetype/cli_spec.rb

@@ -0,0 +1,132 @@
+require 'spec_helper'
+
+RSpec.describe AppArchetype::CLI do
+  subject { described_class.new }
+
+  describe '.manager' do
+    let(:manager) { double }
+    let(:template_dir) { 'path/to/templates' }
+
+    before do
+      allow(described_class).to receive(:template_dir).and_return(template_dir)
+      allow(AppArchetype::TemplateManager).to receive(:new).and_return(manager)
+
+      allow(manager).to receive(:load)
+
+      @manager = described_class.manager
+    end
+
+    it 'creates a manager' do
+      expect(AppArchetype::TemplateManager)
+        .to have_received(:new)
+        .with(template_dir)
+
+      expect(manager).to have_received(:load)
+      expect(@manager).to eq manager
+    end
+  end
+
+  describe '.template_dir' do
+    let(:env_template_dir) { 'path/to/templates' }
+    let(:exist) { true }
+
+    before do
+      allow(ENV).to receive(:[])
+        .with('ARCHETYPE_TEMPLATE_DIR')
+        .and_return(env_template_dir)
+
+      allow(File).to receive(:exist?).and_return(exist)
+    end
+
+    it 'returns template dir' do
+      expect(described_class.template_dir).to eq env_template_dir
+    end
+
+    context 'when ARCHETYPE_TEMPLATE_DIR environment variable not set' do
+      let(:env_template_dir) { nil }
+
+      it 'raises environment not set error' do
+        expect { described_class.template_dir }.to raise_error(
+          RuntimeError,
+          'ARCHETYPE_TEMPLATE_DIR environment variable not set'
+        )
+      end
+    end
+
+    context 'when templates do not exist' do
+      let(:exist) { false }
+
+      it 'raises environment not set error' do
+        expect { described_class.template_dir }.to raise_error(
+          RuntimeError,
+          "ARCHETYPE_TEMPLATE_DIR #{env_template_dir} does not exist"
+        )
+      end
+    end
+  end
+
+  describe '.editor' do
+    let(:env_editor) { 'ivm' }
+    let(:exit_status) { 0 }
+
+    before do
+      allow(ENV).to receive(:[])
+        .with('ARCHETYPE_EDITOR')
+        .and_return(env_editor)
+
+      allow(described_class).to receive(:`)
+      allow($?).to receive(:exitstatus).and_return(exit_status)
+    end
+
+    it 'returns editor' do
+      expect(described_class.editor).to eq env_editor
+    end
+
+    context 'when ARCHETYPE_EDITOR environment variable not set' do
+      let(:env_editor) { nil }
+
+      it 'raises environment not set error' do
+        expect { described_class.editor }.to raise_error(
+          RuntimeError,
+          'ARCHETYPE_EDITOR environment variable not set'
+        )
+      end
+    end
+
+    context 'when editor check does not pass' do
+      let(:exit_status) { 1 }
+
+      before do
+        allow(AppArchetype::CLI).to receive(:print_warning)
+        described_class.editor
+      end
+
+      it 'logs a warning' do
+        expect(AppArchetype::CLI)
+          .to have_received(:print_warning)
+          .with(
+            "WARN: Configured editor #{env_editor} is not installed correctly "\
+            'please check your configuration'
+          )
+      end
+    end
+  end
+
+  describe '.exit_on_failure?' do
+    it 'returns true' do
+      expect(described_class.exit_on_failure?).to be true
+    end
+  end
+
+  describe '#version' do
+    before do
+      allow(subject).to receive(:print_message)
+      subject.version
+    end
+
+    it 'prints current version number' do
+      expect(subject).to have_received(:print_message)
+        .with(AppArchetype::VERSION)
+    end
+  end
+end

data/spec/app_archetype/generators_spec.rb

@@ -0,0 +1,119 @@
+require 'spec_helper'
+
+RSpec.describe AppArchetype::Generators do
+  describe '::TEMPLATE_MANIFEST' do
+    let(:name) { 'project' }
+
+    before do
+      @manifest = OpenStruct.new(
+        described_class::TEMPLATE_MANIFEST.call(name)
+      )
+    end
+
+    it 'has expected name' do
+      expect(@manifest.name).to eq name
+    end
+
+    it 'has expected version' do
+      expect(@manifest.version).to eq '1.0.0'
+    end
+
+    it 'has app archetype metadata' do
+      expect(@manifest.metadata['app_archetype']).not_to be nil
+    end
+
+    it 'renders app version into archetype metadata' do
+      expect(@manifest.metadata['app_archetype']['version'])
+        .to eq AppArchetype::VERSION
+    end
+
+    it 'has default variables' do
+      expect(@manifest.variables).to eq described_class::DEFAULT_VARS
+    end
+
+    it 'renders a manifest that is compliant with the manifest schema' do
+      expect(
+        JSON::Validator.fully_validate(
+          AppArchetype::Template::Manifest::SCHEMA,
+          @manifest.to_h.to_json,
+          strict: true
+        ).empty?
+      ).to be true
+    end
+  end
+
+  describe '::TEMPLATE_README' do
+    let(:name) { 'project' }
+
+    before do
+      @readme = described_class::TEMPLATE_README.call(name)
+    end
+
+    it 'renders name into heading' do
+      expect(@readme.include?("# #{name} Template")).to be true
+    end
+
+    it 'renders name into generation example' do
+      expect(@readme.include?("mkdir my_#{name}")).to be true
+      expect(@readme.include?("cd $HOME/Code/my_#{name}")).to be true
+      expect(@readme.include?("archetype render #{name}")).to be true
+    end
+  end
+
+  describe '.render_empty_template' do
+    let(:manifest_file) { double }
+    let(:manifest_path) { File.join(templates_path, 'manifest.json') }
+
+    let(:readme_file) { double }
+    let(:readme_path) { File.join(templates_path, 'README.md') }
+
+    let(:name) { 'new_template' }
+    let(:templates_path) { 'path/to/templates' }
+
+    let(:manifest) { 'manifest' }
+    let(:readme) { 'readme' }
+
+    before do
+      allow(File).to receive(:open)
+        .with(manifest_path, 'w')
+        .and_yield(manifest_file)
+      allow(manifest_file).to receive(:write)
+
+      allow(File).to receive(:open)
+        .with(readme_path, 'w')
+        .and_yield(readme_file)
+      allow(readme_file).to receive(:write)
+
+      allow(FileUtils).to receive(:mkdir_p)
+
+      allow(described_class::TEMPLATE_MANIFEST)
+        .to receive(:call).and_return(manifest)
+
+      allow(described_class::TEMPLATE_README)
+        .to receive(:call).and_return(readme)
+
+      described_class.render_empty_template(
+        name,
+        templates_path
+      )
+    end
+
+    it 'makes template dir' do
+      expect(FileUtils)
+        .to have_received(:mkdir_p)
+        .with(File.join(templates_path, name))
+    end
+
+    it 'renders blank manifest' do
+      expect(manifest_file)
+        .to have_received(:write)
+        .with("\"#{manifest}\"")
+    end
+
+    it 'renders readme' do
+      expect(readme_file)
+        .to have_received(:write)
+        .with(readme)
+    end
+  end
+end

data/spec/app_archetype/logger_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+
+RSpec.describe AppArchetype::Logger do
+  let(:logger) { double(Logger) }
+  let(:err_logger) { double(Logger) }
+  let(:message) { 'All work and no play makes Jack a dull boy' }
+
+  subject { Object.new.extend(described_class) }
+
+  before do
+    allow(subject).to receive(:exit).and_return(double)
+  end
+
+  describe '.logger' do
+    let(:out) { double(STDOUT) }
+    before do
+      allow(Logger).to receive(:new).and_return(logger)
+      allow(logger).to receive(:formatter=)
+
+      subject.logger(out)
+    end
+
+    it 'creates a new logger to STDOUT' do
+      expect(Logger).to have_received(:new).with(out)
+    end
+  end
+
+  describe '.print_message' do
+    let(:logger) { double(Logger) }
+
+    before do
+      allow(subject).to receive(:logger).and_return(logger)
+      allow(logger).to receive(:info)
+      subject.print_message(message)
+    end
+
+    it 'prints message to stdout' do
+      expect(logger).to have_received(:info).with(message)
+    end
+  end
+
+  describe '.print_warning' do
+    let(:logger) { double(Logger) }
+
+    before do
+      allow(subject).to receive(:logger).and_return(logger)
+      allow(logger).to receive(:warn)
+      subject.print_warning(message)
+    end
+
+    it 'prints message to stdout' do
+      expect(logger).to have_received(:warn).with(message)
+    end
+  end
+
+  describe '.print_error' do
+    let(:logger) { double(Logger) }
+
+    before do
+      allow(subject).to receive(:logger).and_return(logger)
+      allow(logger).to receive(:error)
+      subject.print_error(message)
+    end
+
+    it 'prints message to stderr' do
+      expect(logger).to have_received(:error).with(message)
+    end
+  end
+
+  describe '.print_message_and_exit' do
+    let(:exit_code) { 2 }
+
+    before do
+      allow(subject).to receive(:print_message)
+      subject.print_message_and_exit(message, exit_code)
+    end
+
+    it 'prints message' do
+      expect(subject).to have_received(:print_message).with(message)
+    end
+
+    it 'exits with set status' do
+      expect(subject).to have_received(:exit).with(exit_code)
+    end
+  end
+end

data/spec/app_archetype/renderer_spec.rb

@@ -0,0 +1,291 @@
+require 'spec_helper'
+
+RSpec.describe AppArchetype::Renderer do
+  let(:logger) { double(Logger) }
+  let(:template) { AppArchetype::Template::Source.new('path/to/template') }
+  let(:destination) { 'path/to/destination' }
+  let(:variables) do
+    OpenStruct.new(
+      foo: 'bar'
+    )
+  end
+  let(:plan) do
+    AppArchetype::Template::Plan.new(
+      template,
+      variables,
+      destination_path: destination
+    )
+  end
+  let(:overwrite) { false }
+
+  before do
+    allow(subject).to receive(:logger).and_return(logger)
+    allow(logger).to receive(:info)
+  end
+
+  subject { described_class.new(plan, overwrite) }
+
+  describe '#render' do
+    let(:file) do
+      AppArchetype::Template::OutputFile.new(
+        'path/to/source/file',
+        'path/to/destination/file'
+      )
+    end
+
+    let(:erb_template) do
+      AppArchetype::Template::OutputFile.new(
+        'path/to/template.erb',
+        'path/to/destination/template'
+      )
+    end
+
+    let(:hbs_template) do
+      AppArchetype::Template::OutputFile.new(
+        'path/to/template.hbs',
+        'path/to/destination/template'
+      )
+    end
+
+    let(:directory) do
+      AppArchetype::Template::OutputFile.new(
+        'path/to/source/dir',
+        'path/to/destination/dir'
+      )
+    end
+
+    let(:file_double) { double(File) }
+
+    before do
+      allow(subject).to receive(:write_dir)
+      allow(subject).to receive(:render_erb_file)
+      allow(subject).to receive(:render_hbs_file)
+      allow(subject).to receive(:copy_file)
+
+      allow(File).to receive(:new).and_return(file_double)
+
+      allow(file).to receive(:source_file?).and_return(true)
+      allow(erb_template).to receive(:source_erb?).and_return(true)
+      allow(hbs_template).to receive(:source_hbs?).and_return(true)
+      allow(directory).to receive(:source_directory?).and_return(true)
+
+      plan.instance_variable_set(
+        :@files,
+        [file, erb_template, hbs_template, directory]
+      )
+
+      subject.render
+    end
+
+    it 'creates destination directory' do
+      expect(subject).to have_received(:write_dir).with(file_double)
+    end
+
+    it 'creates directory' do
+      expect(subject).to have_received(:write_dir).with(directory)
+    end
+
+    it 'renders erb template' do
+      expect(subject).to have_received(:render_erb_file).with(erb_template)
+    end
+
+    it 'renders hbs template' do
+      expect(subject).to have_received(:render_hbs_file).with(hbs_template)
+    end
+
+    it 'copies file' do
+      expect(subject).to have_received(:copy_file).with(file)
+    end
+
+    context 'when no method error is raised' do
+      before do
+        allow(subject).to receive(:render_erb_file).and_raise(NoMethodError.new)
+
+        plan.instance_variable_set(
+          :@files,
+          [erb_template]
+        )
+      end
+
+      it 'raises missing variable error' do
+        expect { subject.render }.to raise_error(
+          RuntimeError,
+          'error rendering path/to/destination/template cannot '\
+          'find variable `` in template'
+        )
+      end
+    end
+
+    context 'when no template is invalid' do
+      before do
+        allow(subject).to receive(:render_erb_file).and_raise(SyntaxError.new)
+
+        plan.instance_variable_set(
+          :@files,
+          [erb_template]
+        )
+      end
+
+      it 'raises missing variable error' do
+        expect { subject.render }.to raise_error(
+          RuntimeError,
+          'error parsing path/to/destination/template template is invalid'
+        )
+      end
+    end
+  end
+
+  describe '#write_dir' do
+    let(:source_path) { 'path/to/template/dir' }
+    let(:dest_path) { 'path/to/destination/dir' }
+    let(:dir) { AppArchetype::Template::OutputFile.new(source_path, dest_path) }
+    let(:exists) { false }
+
+    before do
+      allow(FileUtils).to receive(:mkdir_p)
+    end
+
+    it 'creates directory' do
+      subject.write_dir(dir)
+      expect(FileUtils).to have_received(:mkdir_p).with(dest_path)
+    end
+  end
+
+  describe '#render_erb_file' do
+    let(:source_path) { 'path/to/template/file' }
+    let(:dest_path) { 'path/to/destination/file' }
+
+    let(:file) do
+      AppArchetype::Template::OutputFile.new(source_path, dest_path)
+    end
+
+    let(:input) do
+      <<~INPUT
+        this is the content of the <%= foo %> file
+      INPUT
+    end
+
+    let(:expected_output) do
+      <<~OUTPUT
+        this is the content of the bar file
+      OUTPUT
+    end
+
+    let(:write_double) { double }
+
+    before do
+      allow(File).to receive(:read).and_return(input)
+      allow(File).to receive(:open).and_yield(write_double)
+      allow(write_double).to receive(:write)
+
+      subject.render_erb_file(file)
+    end
+
+    it 'reads source' do
+      expect(File).to have_received(:read).with(source_path)
+    end
+
+    it 'writes rendered template' do
+      expect(write_double).to have_received(:write).with(expected_output)
+    end
+
+    context 'when a variable is missing' do
+      let(:vars) { OpenStruct.new }
+      let(:var_value) { '' }
+
+      it 'renders template with blank' do
+        expect(write_double).to have_received(:write).with(expected_output)
+      end
+    end
+  end
+
+  describe '#render_hbs_file' do
+    let(:source_path) { 'path/to/template/file' }
+    let(:dest_path) { 'path/to/destination/file' }
+
+    let(:file) do
+      AppArchetype::Template::OutputFile.new(source_path, dest_path)
+    end
+
+    let(:input) do
+      <<~INPUT
+        this is the content of the {{ foo }} file
+      INPUT
+    end
+
+    let(:expected_output) do
+      <<~OUTPUT
+        this is the content of the bar file
+      OUTPUT
+    end
+
+    let(:write_double) { double }
+
+    before do
+      allow(File).to receive(:read).and_return(input)
+      allow(File).to receive(:open).and_yield(write_double)
+      allow(write_double).to receive(:write)
+
+      subject.render_hbs_file(file)
+    end
+
+    it 'reads source' do
+      expect(File).to have_received(:read).with(source_path)
+    end
+
+    it 'writes rendered template' do
+      expect(write_double).to have_received(:write).with(expected_output)
+    end
+
+    context 'when a variable is missing' do
+      let(:vars) { OpenStruct.new }
+      let(:var_value) { '' }
+
+      it 'renders template with blank' do
+        expect(write_double).to have_received(:write).with(expected_output)
+      end
+    end
+  end
+
+  describe '#copy_file' do
+    let(:source_path) { 'path/to/template/file' }
+    let(:dest_path) { 'path/to/destination/file' }
+
+    let(:file) do
+      AppArchetype::Template::OutputFile.new(source_path, dest_path)
+    end
+
+    let(:exists) { false }
+
+    before do
+      allow(FileUtils).to receive(:cp)
+      allow(file).to receive(:exist?).and_return(exists)
+    end
+
+    it 'copies file' do
+      subject.copy_file(file)
+      expect(FileUtils).to have_received(:cp).with(source_path, dest_path)
+    end
+
+    context 'when file already exists and overwrite not allowed' do
+      let(:exists) { true }
+
+      it 'raises error' do
+        expect do
+          subject.copy_file(file)
+        end.to raise_error('cannot overwrite file')
+      end
+    end
+
+    context 'when file already exists and overwrite is allowed' do
+      let(:exists) { true }
+      let(:overwrite) { true }
+
+      it 'raises error' do
+        expect do
+          subject.copy_file(file)
+        end.not_to raise_error
+      end
+    end
+  end
+end