app_archetype 1.2.3

data/lib/app_archetype/template/variable_manager.rb

@@ -0,0 +1,75 @@
+require 'ostruct'
+require 'json'
+
+module AppArchetype
+  module Template
+    # Manages a collection of variables
+    class VariableManager
+      def initialize(vars)
+        vars ||= []
+        @data = []
+
+        vars.each do |name, spec|
+          @data << AppArchetype::Template::Variable.new(name, spec)
+        end
+      end
+
+      ##
+      # Returns all variables managed by the variable manager.
+      #
+      # @return [Array]
+      #
+      def all
+        @data
+      end
+
+      ##
+      # Retrieves a variable by name from the variable manager.
+      #
+      # @param [String] name
+      #
+      # @return [AppArchetype::Template::Variable]
+      #
+      def get(name)
+        @data.detect { |var| var.name == name }
+      end
+
+      ##
+      # Creates a hash representation of variables.
+      #
+      # The variable name is the key, and the currrent value
+      # is the value.
+      #
+      # @return [Hash]
+      #
+      def to_h
+        var_hash = {}
+
+        @data.each do |var|
+          var_hash[var.name] = var.value
+        end
+
+        var_hash
+      end
+
+      ##
+      # Method missing retrieves variable from manager and
+      # returns the value to the caller if it is found.
+      #
+      # When a call is made to an undefined variable, a
+      # MethodMissing error will be raised.
+      #
+      # @param [Symbol] method
+      # @param [Array] args
+      #
+      # @return [Object]
+      #
+      def method_missing(method, *args)
+        var = get(method.to_s)
+        return var.value if var
+
+        super
+      end
+    end
+  end
+end

data/lib/app_archetype/template_manager.rb

@@ -0,0 +1,113 @@
+module AppArchetype
+  # Manager looks after a set of archetypes
+  class TemplateManager
+    ##
+    # Default filter is a lambda that returns true for all manifests
+    #
+    DEFAULT_QUERY = ->(_manifest) { return true }
+
+    attr_reader :manifests
+
+    ##
+    # Creates a manager
+    #
+    # @param [String] template_dir
+    #
+    def initialize(template_dir)
+      @template_dir = template_dir
+      @manifests = []
+    end
+
+    ##
+    # Loads and parses each manifest within the template directory into
+    # memory. Any invalid manifests are ignored and a message is printed
+    # to STDOUT indicating which manifest is not valid.
+    #
+    def load
+      Dir.glob(
+        File.join(@template_dir, '**', 'manifest.json*')
+      ).each do |manifest|
+        begin
+          @manifests << AppArchetype::Template::Manifest.new_from_file(manifest)
+        rescue StandardError
+          puts "WARN: `#{manifest}` is invalid, skipping"
+          next
+        end
+      end
+    end
+
+    ##
+    # Filter executes a query function in a select call against each manifest
+    # in the manager's collection.
+    #
+    # The given query function should be something that will evaluate to true
+    # when the manifest matches - this will hence filter the manifest set to
+    # the filtered set.
+    #
+    # @example
+    #   manager = AppArchetype::TemplateManager.new('/path/to/templates')
+    #   query = -> (manifest) { manifest.name = "fudge" }
+    #
+    #   fudge_templates = manager.filter(query)
+    #
+    # @param [Lambda] query
+    #
+    # @return [Array]
+    def filter(query = DEFAULT_QUERY)
+      @manifests.select do |template|
+        query.call(template)
+      end
+    end
+
+    ##
+    # Searches for manifests matching given name and returns it to caller.
+    #
+    # @example:
+    #   manager = AppArchetype::TemplateManager.new('/path/to/templates')
+    #   fudge_manifest = manager.find('fudge')
+    #
+    # @param [String] name
+    #
+    # @return [Array]
+    #
+    def search_by_name(name)
+      name_query = lambda do |template|
+        template.name.include?(name)
+      end
+
+      filter(name_query)
+    end
+
+    ##
+    # Finds a specific manifest by name and returns it to the caller.
+    #
+    # It is possible that a more than one manifest is found when searching
+    # by name. If this happens while ignore_dupe is set to false, then a
+    # Runtime error is raised. If ignore_dupe is set to false then the first
+    # matching manifest is returned.
+    #
+    # @example:
+    #   manager = AppArchetype::TemplateManager.new('/path/to/templates')
+    #   fudge_manifest = manager.find('fudge')
+    #
+    # @param [String] name
+    # @param [Boolean] ignore_dupe
+    #
+    # @return [AppArchetype::Template::Manifest]
+    #
+    def find_by_name(name, ignore_dupe: false)
+      name_query = lambda do |template|
+        template.name == name
+      end
+
+      results = filter(name_query)
+
+      if results.count > 1 && ignore_dupe == false
+        raise 'more than one manifest matching the'\
+        ' given name were found'
+      end
+
+      results.first
+    end
+  end
+end

data/lib/app_archetype/version.rb

@@ -0,0 +1,6 @@
+module AppArchetype
+  ##
+  # AppArchetype version
+  #
+  VERSION = '1.2.3'.freeze
+end

data/lib/core_ext/string.rb

@@ -0,0 +1,67 @@
+require 'app_archetype/template/helpers'
+
+# Archetype extensions for String
+class String
+  ##
+  # Converts string to snake case
+  #
+  # @return [String]
+  #
+  def snake_case
+    helper.snake_case(self)
+  end
+
+  ##
+  # Converts string to dash case
+  #
+  # @return [String]
+  #
+  def dash_case
+    helper.dash_case(self)
+  end
+
+  ##
+  # Converts a string to camel case
+  #
+  # @return [String]
+  #
+  def camel_case
+    helper.camel_case(self)
+  end
+
+  ##
+  # Attempts to pluralize a word
+  #
+  # @return [String]
+  #
+  def pluralize
+    helper.pluralize(self)
+  end
+
+  ##
+  # Attempts to singluarize a word
+  #
+  # @return [String]
+  #
+  def singularize
+    helper.singularize(self)
+  end
+
+  ##
+  # Adds a random string of specified length at the end
+  #
+  # @return [String]
+  #
+  def randomize(size = 5)
+    helper.randomize(self, size.to_s)
+  end
+
+  private
+
+  # Instance helper methods
+  def helper
+    Object
+      .new
+      .extend(AppArchetype::Template::Helpers)
+  end
+end

data/spec/app_archetype/cli/presenters_spec.rb

@@ -0,0 +1,99 @@
+require 'spec_helper'
+
+RSpec.describe AppArchetype::CLI::Presenters do
+  describe '.manifest_list' do
+    let(:manifest) do
+      double(
+        AppArchetype::Template::Manifest,
+        name: 'test_manifest',
+        version: '1.0.0'
+      )
+    end
+    let(:manifest_list_row) { ['test_manifest', '1.0.0'] }
+
+    let(:presenter) { double(CliFormat::Presenter) }
+    let(:manifests) { [manifest, manifest] }
+
+    before do
+      allow(presenter).to receive(:show)
+      allow(subject).to receive(:table).and_return(presenter)
+
+      described_class.manifest_list(manifests)
+    end
+
+    it 'builds table presenter' do
+      expect(subject).to have_received(:table).with(
+        header: AppArchetype::CLI::Presenters::RESULT_HEADER,
+        data: [manifest_list_row, manifest_list_row]
+      )
+    end
+
+    it 'shows table' do
+      expect(presenter).to have_received(:show)
+    end
+  end
+
+  describe '.variable_list' do
+    let(:variable) do
+      double(
+        AppArchetype::Template::Variable,
+        name: 'foo',
+        description: 'a foo',
+        default: 'yolo',
+        value: 'bar'
+      )
+    end
+    let(:variable_row) { ['foo', 'a foo', 'yolo'] }
+
+    let(:presenter) { double(CliFormat::Presenter) }
+    let(:variables) { [variable, variable] }
+
+    before do
+      allow(presenter).to receive(:show)
+      allow(subject).to receive(:table).and_return(presenter)
+
+      described_class.variable_list(variables)
+    end
+
+    it 'builds table presenter' do
+      expect(subject).to have_received(:table).with(
+        header: AppArchetype::CLI::Presenters::VARIABLE_HEADER,
+        data: [variable_row, variable_row]
+      )
+    end
+
+    it 'shows table' do
+      expect(presenter).to have_received(:show)
+    end
+  end
+
+  describe '.validation_results' do
+    let(:results) do
+      [
+        'something went wrong',
+        'something went wrong'
+      ]
+    end
+
+    let(:result_row) { ['something went wrong'] }
+    let(:presenter) { double(CliFormat::Presenter) }
+
+    before do
+      allow(presenter).to receive(:show)
+      allow(subject).to receive(:table).and_return(presenter)
+
+      described_class.validation_result(results)
+    end
+
+    it 'builds table presenter' do
+      expect(subject).to have_received(:table).with(
+        header: AppArchetype::CLI::Presenters::VALIDATION_HEADER,
+        data: [result_row, result_row]
+      )
+    end
+
+    it 'shows table' do
+      expect(presenter).to have_received(:show)
+    end
+  end
+end

data/spec/app_archetype/cli/prompts_spec.rb

@@ -0,0 +1,292 @@
+require 'spec_helper'
+
+RSpec.describe AppArchetype::CLI::Prompts do
+  let(:var_name) { 'foo' }
+  let(:var_type) { 'string' }
+  let(:var_desc) { 'a foo' }
+  let(:var_default) { 'bar' }
+  let(:var_value) { nil }
+
+  let(:variable) do
+    double(
+      AppArchetype::Template::Variable,
+      name: var_name,
+      description: var_desc,
+      type: var_type,
+      default: var_default,
+      value: var_value
+    )
+  end
+
+  describe '::VAR_PROMPT_MESSAGE' do
+    before do
+      @prompt = described_class::VAR_PROMPT_MESSAGE.call(variable)
+    end
+
+    it 'displays prompt' do
+      expect(
+        @prompt.include?("Enter value for `#{var_name}` variable")
+      ).to be true
+    end
+
+    it 'displays variable description' do
+      expect(@prompt.include?("DESCRIPTION: #{var_desc}")).to be true
+    end
+
+    it 'displays variable type' do
+      expect(@prompt.include?("TYPE: #{var_type}")).to be true
+    end
+
+    it 'displays variable default' do
+      expect(@prompt.include?("DEFAULT: #{var_default}")).to be true
+    end
+  end
+
+  describe '.prompt' do
+    it 'returns a prompt' do
+      expect(described_class.prompt).to be_a(HighLine)
+    end
+  end
+
+  describe '.yes?' do
+    let(:prompt) { double(HighLine) }
+    let(:message) { 'Would you like to do stuff?' }
+    let(:response) { 'Y' }
+
+    before do
+      allow(subject).to receive(:prompt).and_return(prompt)
+      allow(prompt).to receive(:ask).and_yield(response)
+
+      @resp = subject.yes?(message)
+    end
+
+    it 'asks question' do
+      expect(prompt).to have_received(:ask).with("#{message} [Y/n]", String)
+    end
+
+    it 'returns true when user responds Y' do
+      expect(@resp).to be true
+    end
+
+    context 'when user inputs anything other than Y' do
+      let(:response) { 'Nope' }
+
+      it 'returns false' do
+        expect(@resp).to be false
+      end
+    end
+  end
+
+  describe '.ask' do
+    let(:prompt) { double(HighLine) }
+
+    let(:message) { 'Give me some info' }
+    let(:validator) { String }
+    let(:default) { 'Default' }
+
+    let(:response) { 'Sure here it is' }
+
+    before do
+      allow(subject).to receive(:prompt).and_return(prompt)
+      allow(prompt).to receive(:ask).and_return(response)
+
+      @resp = subject.ask(message, validator: validator, default: default)
+    end
+
+    it 'asks question with validator' do
+      expect(prompt).to have_received(:ask).with(message, validator)
+    end
+
+    it 'returns user response as string' do
+      expect(@resp).to eq response
+    end
+
+    context 'when default is specifed and empty response' do
+      let(:response) { '' }
+
+      it 'returns default' do
+        expect(@resp).to eq default
+      end
+    end
+
+    context 'when empty and no default specified' do
+      let(:default) { nil }
+      let(:response) { '' }
+
+      it 'returns empty string' do
+        expect(@resp).to eq ''
+      end
+    end
+
+    context 'when asking for an integer' do
+      let(:response) { 1 }
+      let(:validator) { Integer }
+
+      it 'returns user response as integer' do
+        expect(@resp).to eq 1
+      end
+    end
+  end
+
+  describe '.delete_template' do
+    let(:prompt) { double(HighLine) }
+
+    let(:manifest_name) { 'test_manifest' }
+    let(:manifest) do
+      double(AppArchetype::Template::Manifest, name: manifest_name)
+    end
+
+    let(:choice) { false }
+
+    before do
+      allow(subject).to receive(:prompt).and_return(prompt)
+      allow(subject).to receive(:yes?).and_return(choice)
+
+      @result = described_class.delete_template(manifest)
+    end
+
+    it 'asks if it is okay to delete template' do
+      expect(subject).to have_received(:yes?)
+        .with('Are you sure you want to delete `test_manifest`?')
+    end
+
+    it 'returns user choice' do
+      expect(@result).to eq choice
+    end
+  end
+
+  describe '.variable_prompt_for' do
+    let(:has_value) { false }
+
+    before do
+      allow(variable).to receive(:value?).and_return(has_value)
+
+      allow(described_class).to receive(:boolean_variable_prompt)
+      allow(described_class).to receive(:integer_variable_prompt)
+      allow(described_class).to receive(:string_variable_prompt)
+    end
+
+    context 'when variable value is set' do
+      let(:has_value) { true }
+      let(:var_value) { 'some-value' }
+
+      it 'returns value' do
+        expect(
+          described_class.variable_prompt_for(variable)
+        ).to eq var_value
+      end
+    end
+
+    context 'when variable type is a boolean' do
+      let(:var_type) { 'boolean' }
+
+      before { described_class.variable_prompt_for(variable) }
+
+      it 'calls boolean variable prompt' do
+        expect(described_class)
+          .to have_received(:boolean_variable_prompt)
+          .with(variable)
+      end
+    end
+
+    context 'when variable type is an integer' do
+      let(:var_type) { 'integer' }
+
+      before { described_class.variable_prompt_for(variable) }
+
+      it 'calls integer variable prompt' do
+        expect(described_class)
+          .to have_received(:integer_variable_prompt)
+          .with(variable)
+      end
+    end
+
+    context 'when variable type is a string' do
+      let(:var_type) { 'string' }
+
+      before { described_class.variable_prompt_for(variable) }
+
+      it 'calls string variable prompt' do
+        expect(described_class)
+          .to have_received(:string_variable_prompt)
+          .with(variable)
+      end
+    end
+
+    context 'treats variables as strings by default' do
+      let(:var_type) { nil }
+
+      before { described_class.variable_prompt_for(variable) }
+
+      it 'calls string variable prompt' do
+        expect(described_class)
+          .to have_received(:string_variable_prompt)
+          .with(variable)
+      end
+    end
+  end
+
+  describe '.boolean_variable_prompt' do
+    let(:choice) { false }
+
+    before do
+      allow(subject).to receive(:yes?).and_return(choice)
+      @result = described_class.boolean_variable_prompt(variable)
+    end
+
+    it 'asks for boolean input' do
+      expect(subject).to have_received(:yes?)
+        .with(
+          AppArchetype::CLI::Prompts::VAR_PROMPT_MESSAGE.call(variable)
+        )
+    end
+
+    it 'returns user choice' do
+      expect(@result).to eq choice
+    end
+  end
+
+  describe '.integer_variable_prompt' do
+    let(:choice) { 1 }
+
+    before do
+      allow(subject).to receive(:ask).and_return(choice)
+      @result = described_class.integer_variable_prompt(variable)
+    end
+
+    it 'asks for boolean input' do
+      expect(subject).to have_received(:ask)
+        .with(
+          AppArchetype::CLI::Prompts::VAR_PROMPT_MESSAGE.call(variable),
+          default: variable.default,
+          validator: Integer
+        )
+    end
+
+    it 'returns user choice' do
+      expect(@result).to eq choice
+    end
+  end
+
+  describe '.string_variable_prompt' do
+    let(:choice) { 'some string' }
+
+    before do
+      allow(subject).to receive(:ask).and_return(choice)
+
+      @result = described_class.string_variable_prompt(variable)
+    end
+
+    it 'asks for boolean input' do
+      expect(subject).to have_received(:ask)
+        .with(
+          AppArchetype::CLI::Prompts::VAR_PROMPT_MESSAGE.call(variable),
+          default: variable.default
+        )
+    end
+
+    it 'returns user choice' do
+      expect(@result).to eq choice
+    end
+  end
+end