app_archetype 1.2.3

data/spec/app_archetype/template/plan_spec.rb

@@ -0,0 +1,191 @@
+require 'spec_helper'
+
+RSpec.describe AppArchetype::Template::Plan do
+  let(:template) { AppArchetype::Template::Source.new('path/to/template') }
+  let(:destination) { 'path/to/destination' }
+  let(:variables) do
+    OpenStruct.new(
+      foo: 'bar'
+    )
+  end
+
+  subject do
+    described_class.new(
+      template,
+      variables,
+      destination_path: destination
+    )
+  end
+
+  describe '#devise' do
+    let(:dest_exist) { true }
+
+    before do
+      allow(subject).to receive(:destination_exist?).and_return(dest_exist)
+      allow(template).to receive(:files).and_return(['path/to/file'])
+    end
+
+    it 'creates file objects' do
+      subject.devise
+      expect(subject.files).to all be_a(AppArchetype::Template::OutputFile)
+    end
+
+    context 'destination path does not exist' do
+      let(:dest_exist) { false }
+
+      it 'raises error' do
+        expect do
+          subject.devise
+        end.to raise_error('destination path does not exist')
+      end
+    end
+  end
+
+  describe '#execute' do
+    let(:renderer) { double(AppArchetype::Renderer) }
+
+    before do
+      allow(renderer).to receive(:render)
+      allow(AppArchetype::Renderer)
+        .to receive(:new)
+        .and_return(renderer)
+
+      subject.execute
+    end
+
+    it 'creates a renderer' do
+      expect(AppArchetype::Renderer)
+        .to have_received(:new).with(subject, false)
+    end
+
+    it 'renders plan' do
+      expect(renderer).to have_received(:render)
+    end
+  end
+
+  describe '#destination_exist?' do
+    let(:dirname) { 'some-directory' }
+    let(:exist) { true }
+
+    before do
+      allow(File).to receive(:exist?).and_return(exist)
+      allow(File).to receive(:dirname).and_return(dirname)
+    end
+
+    it 'returns true' do
+      expect(subject.destination_exist?).to be true
+    end
+
+    context 'when destination does not exist' do
+      let(:exist) { false }
+
+      it 'returns false' do
+        expect(subject.destination_exist?).to be false
+      end
+    end
+  end
+
+  describe '#render_dest_file_path' do
+    it 'creates a destination file path from source path' do
+      expect(
+        subject.render_dest_file_path('path/to/template/file')
+      ).to eq 'path/to/destination/file'
+    end
+  end
+
+  describe '#render_path' do
+    it 'renders path with variables' do
+      expect(subject.render_path('{{foo}}')).to eq 'bar'
+    end
+  end
+end
+
+RSpec.describe AppArchetype::Template::OutputFile do
+  let(:source_file) { 'path/to/source' }
+  let(:dest_file) { 'path/to/dest' }
+
+  subject { described_class.new(source_file, dest_file) }
+
+  describe '#source_directory?' do
+    before do
+      allow(File).to receive(:directory?)
+      subject.source_directory?
+    end
+
+    it 'delegates source file directory check to File' do
+      expect(File).to have_received(:directory?).with(source_file)
+    end
+  end
+
+  describe '#source_erb?' do
+    let(:ext) { '.erb' }
+
+    before do
+      allow(File).to receive(:extname).and_return(ext)
+      @result = subject.source_erb?
+    end
+
+    it 'delegates source file template check to File' do
+      expect(File).to have_received(:extname).with(source_file)
+    end
+
+    it 'returns true if file is erb' do
+      expect(@result).to be true
+    end
+
+    context 'when not erb' do
+      let(:ext) { 'doc' }
+
+      it 'returns false' do
+        expect(@result).to be false
+      end
+    end
+  end
+
+  describe '#source_hbs?' do
+    let(:ext) { '.hbs' }
+
+    before do
+      allow(File).to receive(:extname).and_return(ext)
+      @result = subject.source_hbs?
+    end
+
+    it 'delegates source file template check to File' do
+      expect(File).to have_received(:extname).with(source_file)
+    end
+
+    it 'returns true if file is hbs' do
+      expect(@result).to be true
+    end
+
+    context 'when not hbs' do
+      let(:ext) { 'doc' }
+
+      it 'returns false' do
+        expect(@result).to be false
+      end
+    end
+  end
+
+  describe '#source_file?' do
+    before do
+      allow(File).to receive(:file?)
+      subject.source_file?
+    end
+
+    it 'delegates source file check to File' do
+      expect(File).to have_received(:file?).with(source_file)
+    end
+  end
+
+  describe '#exist?' do
+    before do
+      allow(File).to receive(:exist?)
+      subject.exist?
+    end
+
+    it 'delegates exist check to File' do
+      expect(File).to have_received(:exist?).with(dest_file)
+    end
+  end
+end

data/spec/app_archetype/template/source_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+RSpec.describe AppArchetype::Template::Source do
+  let(:path) { 'path/to/source' }
+  subject { described_class.new(path) }
+
+  describe '#load' do
+    let(:glob_files) { %w[file1 file2] }
+    let(:exist) { true }
+
+    before do
+      allow(Dir).to receive(:glob).and_return(glob_files)
+      allow(subject).to receive(:exist?).and_return(exist)
+    end
+
+    context 'when source exists' do
+      before do
+        subject.load
+      end
+
+      it 'loads expected file paths into source_files' do
+        expect(subject.files).to eq glob_files
+      end
+    end
+
+    context 'when source does not exist' do
+      let(:exist) { false }
+
+      it 'raises template source does not exist error' do
+        expect do
+          subject.load
+        end.to raise_error('template source does not exist')
+      end
+    end
+  end
+
+  describe '#exist?' do
+    let(:path) { 'path/to/source' }
+    let(:exist) { true }
+
+    before { allow(File).to receive(:exist?).and_return(exist) }
+
+    it 'checks if file exists' do
+      expect(File).to receive(:exist?).with(path)
+      subject.exist?
+    end
+
+    it 'returns true' do
+      expect(subject.exist?).to be true
+    end
+
+    context 'when file does not exist' do
+      let(:exist) { false }
+
+      it 'returns false' do
+        expect(subject.exist?).to be false
+      end
+    end
+  end
+end

data/spec/app_archetype/template/variable_manager_spec.rb

@@ -0,0 +1,103 @@
+require 'spec_helper'
+
+RSpec.describe AppArchetype::Template::VariableManager do
+  let(:var_name) { 'example_string' }
+  let(:var_type) { 'string' }
+  let(:var_desc) { 'This is an example string variable' }
+  let(:var_default) { 'default value' }
+  let(:var_value) { 'set value' }
+
+  let(:variables_spec) do
+    {
+      var_name => {
+        'type' => var_type,
+        'description' => var_desc,
+        'default' => var_default
+      },
+      "#{var_name}_with_value" => {
+        'type' => var_type,
+        'description' => var_desc,
+        'default' => var_default,
+        'value' => var_value
+      },
+      'example_random_string' => {
+        'type' => 'string',
+        'description' => 'Example call to helper to generate 25 char string',
+        'value' => '#random_string,25'
+      }
+    }
+  end
+
+  subject { described_class.new(variables_spec) }
+
+  describe '#all' do
+    it 'returns array of template variables' do
+      expect(subject.all).to all(be_a AppArchetype::Template::Variable)
+    end
+
+    it 'has expected variables' do
+      expect(subject.all.map(&:name))
+        .to eq(
+          %w[
+            example_string
+            example_string_with_value
+            example_random_string
+          ]
+        )
+    end
+  end
+
+  describe '#get' do
+    before { @var = subject.get(var_name) }
+
+    it 'returns variable' do
+      expect(@var.name).to eq var_name
+      expect(@var.type).to eq var_type
+      expect(@var.description).to eq var_desc
+      expect(@var.default).to eq var_default
+    end
+  end
+
+  describe '#to_h' do
+    let(:instance_helpers) { double }
+    let(:random_result) { 'random-string-25-chars-long' }
+
+    before do
+      allow_any_instance_of(AppArchetype::Template::Variable)
+        .to receive(:helpers)
+        .and_return(instance_helpers)
+
+      allow(instance_helpers)
+        .to receive(:random_string)
+        .and_return(random_result)
+    end
+
+    it 'returns hash representation of variables (key => value)' do
+      expect(subject.to_h).to eq(
+        var_name => var_default,
+        "#{var_name}_with_value" => var_value,
+        'example_random_string' => random_result
+      )
+    end
+  end
+
+  describe '#method_missing' do
+    context 'when variable is defined without value' do
+      it 'returns default variable value' do
+        expect(subject.example_string).to eq var_default
+      end
+    end
+
+    context 'when variable is defined with a value' do
+      it 'returns set variable value' do
+        expect(subject.example_string_with_value).to eq var_value
+      end
+    end
+
+    context 'when variable is not defined' do
+      it 'raises NoMethodError' do
+        expect { subject.foo }.to raise_error(NoMethodError)
+      end
+    end
+  end
+end

data/spec/app_archetype/template/variable_spec.rb

@@ -0,0 +1,245 @@
+require 'spec_helper'
+
+RSpec.describe AppArchetype::Template::Variable do
+  let(:description) { 'explanation of variable' }
+  let(:type) { 'string' }
+  let(:default) { 'default-value' }
+  let(:value) { nil }
+
+  let(:name) { 'var' }
+  let(:spec) do
+    {
+      'description' => description,
+      'type' => type,
+      'default' => default,
+      'value' => value
+    }
+  end
+
+  subject { described_class.new(name, spec) }
+
+  describe '::STRING_VALIDATOR' do
+    it 'returns true when given string input' do
+      expect(
+        described_class::STRING_VALIDATOR.call('this is string')
+      ).to be true
+    end
+
+    it 'returns false when given non string input' do
+      expect(
+        described_class::STRING_VALIDATOR.call(1)
+      ).to be false
+    end
+  end
+
+  describe '::BOOLEAN_VALIDATOR' do
+    it 'returns true when given boolean input' do
+      expect(
+        described_class::BOOLEAN_VALIDATOR.call(true)
+      ).to be true
+    end
+
+    it 'returns true when given string representation of boolean input' do
+      expect(
+        described_class::BOOLEAN_VALIDATOR.call('true')
+      ).to be true
+    end
+
+    it 'returns false when given non boolean input' do
+      expect(
+        described_class::BOOLEAN_VALIDATOR.call('not bool')
+      ).to be false
+    end
+  end
+
+  describe '::INTEGER_VALIDATOR' do
+    it 'returns true when given integer input' do
+      expect(
+        described_class::INTEGER_VALIDATOR.call(1)
+      ).to be true
+    end
+
+    it 'returns true when given string representation of integer' do
+      expect(
+        described_class::INTEGER_VALIDATOR.call('1')
+      ).to be true
+    end
+
+    it 'returns false when given non integer input' do
+      expect(
+        described_class::INTEGER_VALIDATOR.call('one')
+      ).to be false
+    end
+  end
+
+  describe '#set!' do
+    context 'setting with a valid value' do
+      before { subject.set!('a value') }
+
+      it 'sets the value of the variable' do
+        expect(subject.value).to eq 'a value'
+      end
+    end
+
+    context 'setting with an invalid value' do
+      let(:type) { 'integer' }
+
+      it 'raises invalid value runtime error' do
+        expect do
+          subject.set!('a string')
+        end.to raise_error('invalid value')
+      end
+    end
+  end
+
+  describe '#default' do
+    context 'when default is in specification' do
+      it 'returns specified default value' do
+        expect(subject.default).to eq default
+      end
+    end
+
+    context 'when default is not specified' do
+      let(:spec) do
+        {
+          'type' => 'integer'
+        }
+      end
+
+      it 'returns archetype default' do
+        expect(subject.default).to eq 0
+      end
+    end
+  end
+
+  describe '#description' do
+    context 'when description is in specification' do
+      it 'returns specified description value' do
+        expect(subject.description).to eq description
+      end
+    end
+
+    context 'when default is not specified' do
+      let(:spec) do
+        {
+          'type' => 'integer'
+        }
+      end
+
+      it 'returns empty string' do
+        expect(subject.description).to eq ''
+      end
+    end
+  end
+
+  describe '#type' do
+    context 'when type is in specification' do
+      it 'returns specified type value' do
+        expect(subject.type).to eq type
+      end
+    end
+
+    context 'when default is not specified' do
+      let(:spec) do
+        {}
+      end
+
+      it 'returns string by default' do
+        expect(subject.type).to eq 'string'
+      end
+    end
+  end
+
+  describe '#value' do
+    context 'when value is not specified' do
+      it 'returns default value' do
+        expect(subject.value).to eq default
+      end
+    end
+
+    context 'when value is a function call' do
+      let(:helper) { double }
+      let(:value) { '#upcase,foo' }
+
+      it 'returns result of function call' do
+        expect(subject.value).to eq 'FOO'
+      end
+    end
+
+    context 'when value has been set' do
+      let(:value) { 'some-value' }
+
+      it 'returns variable value' do
+        expect(subject.value).to eq value
+      end
+    end
+  end
+
+  describe '#value?' do
+    context 'when value is not set' do
+      let(:value) { nil }
+
+      it 'returns false' do
+        expect(subject.value?).to be false
+      end
+    end
+
+    let(:value) { 'some-value' }
+
+    context 'when value is set' do
+      it 'returns true' do
+        expect(subject.value?).to be true
+      end
+    end
+  end
+
+  describe '#validator' do
+    context 'when variable type is specified' do
+      let(:type) { 'integer' }
+
+      it 'returns validator for specified type' do
+        expect(subject.validator)
+          .to eq AppArchetype::Template::Variable::INTEGER_VALIDATOR
+      end
+    end
+
+    context 'when variable type is not specified' do
+      let(:type) { nil }
+
+      it 'returns string validator' do
+        expect(subject.validator)
+          .to eq AppArchetype::Template::Variable::STRING_VALIDATOR
+      end
+    end
+  end
+
+  describe '#valid?' do
+    context 'when validator returns true' do
+      let(:result) { true }
+      let(:validator) { double(call: result) }
+
+      before do
+        allow(subject).to receive(:validator)
+          .and_return(validator)
+      end
+
+      it 'returns true' do
+        expect(subject.valid?('input')).to be true
+      end
+    end
+
+    context 'when validator returns false' do
+      let(:result) { false }
+      let(:validator) { double(call: result) }
+
+      before do
+        allow(subject).to receive(:validator)
+          .and_return(validator)
+      end
+
+      it 'returns false' do
+        expect(subject.valid?('input')).to be false
+      end
+    end
+  end
+end