klipp 0.0.1 → 0.2.0

data/spec/klipp/creator_spec.rb

@@ -0,0 +1,120 @@
+# coding: utf-8
+require 'spec_helper'
+
+describe Klipp::Creator do
+
+  it 'stores values for template tokens' do
+    creator = Klipp::Creator.new()
+    creator.tokens[:PROJECT_ID] = 'A project id'
+    creator.tokens[:PROJECT_ID].should eq 'A project id'
+  end
+
+  context 'concerning klippfiles' do
+
+    before do
+      Klipp::Configuration.stubs(:root_dir).returns(File.join(File.dirname(__dir__), 'fixtures'))
+      File.directory?(Klipp::Configuration.root_dir).should be true
+    end
+
+    context 'from file' do
+
+      context 'a minimal klippfile' do
+
+        it 'validates' do
+          creator = Klipp::Creator.new()
+          creator.expects(:invalidate).never
+
+          path = fixture_path('Klippfile-minimal')
+          string = read_fixture('Klippfile-minimal')
+          creator.eval_string(string, path)
+        end
+
+      end
+
+      context 'an invalid klippfile' do
+
+        it "raises an error if it's bad ruby" do
+          creator = Klipp::Creator.new()
+          creator.expects(:invalidate).never
+
+          path = fixture_path('Klippfile-bad-ruby')
+          string = read_fixture('Klippfile-bad-ruby')
+          expect { creator.eval_string(string, path) }.to raise_error RuntimeError
+        end
+
+        it "raises an error the Klippfile doesn't exist" do
+          File.stubs(:exists?).returns false
+          expect { Klipp::Creator.from_file ('anywhere/Klippfile') }.to raise_error RuntimeError
+        end
+
+        it 'warns about unambiguous templates' do
+          creator = Klipp::Creator.new()
+          path = fixture_path('Klippfile-unambiguous')
+          string = read_fixture('Klippfile-unambiguous')
+          expect { creator.eval_string(string, path) }.to raise_error Klipp::Hint
+        end
+
+        it 'raises an error for unknown templates' do
+          creator = Klipp::Creator.new()
+          expect { creator.eval_string("create 'Amnesia'", 'fictional-klippspec.rb') }.to raise_error RuntimeError
+        end
+
+        it 'raises an error for empty templates' do
+          creator = Klipp::Creator.new()
+          expect { creator.eval_string("create ''", 'fictional-klippspec.rb') }.to raise_error RuntimeError
+        end
+      end
+
+      context 'a valid klippfile' do
+
+        it 'initializes from a klippfile' do
+          Klipp::Creator.from_file(fixture_path('Klippfile')).should be_an_instance_of Klipp::Creator
+        end
+
+        it 'validates ambiguous templates' do
+          creator = Klipp::Creator.new()
+          creator.expects(:invalidate).never
+          path = fixture_path('Klippfile-ambiguous')
+          string = read_fixture('Klippfile-ambiguous')
+          creator.eval_string(string, path)
+        end
+
+      end
+
+    end
+
+    context 'from user input' do
+
+      before do
+        @input    = StringIO.new
+        @output   = StringIO.new
+        @highline = HighLine.new(@input, @output)
+      end
+
+      it 'validates' do
+        creator = Klipp::Creator.new()
+        creator.expects(:invalidate).never
+
+        @input << "Object\ny\n"
+        @input.rewind
+
+        creator.ask_user_input('Interactive', @highline)
+      end
+
+      it 'invalidates booleans and asks again' do
+        creator = Klipp::Creator.new()
+        creator.expects(:invalidate).never
+
+        @input << "Object\nja\ny\n"
+        @input.rewind
+
+        creator.ask_user_input('Interactive', @highline)
+        p @output.string
+      end
+
+    end
+
+  end
+
+
+end

data/spec/klipp_spec.rb

@@ -3,137 +3,132 @@ require 'spec_helper'
 
 describe Klipp do
 
-  before do
-    @output = Klipp.output = StringIO.new
-  end
-
-  describe 'when routing' do
+  context 'capturing stdout' do
 
-    it 'prints help without any parameters' do
-      expect { Klipp.route *%w[] }.to raise_error SystemExit
-      should include 'Xcode templates for the rest of us.'
+    it 'matches stdout' do
+      capture_stdout {
+        puts "I'm out"
+      }.should eq "I'm out\n"
     end
 
-    it 'prints warnings accordingly' do
-      expect { Klipp.route *%w[prepare Bullshit] }.to raise_error SystemExit
-      should include '[!]'
+    it 'matches formatador stdout' do
+      capture_stdout {
+        Formatador.display_line "I'm [green]green[/]"
+      }.should include "green"
     end
 
-    it 'raises a warning when routing unknown commands' do
-      expect { Klipp.route *%w[allyourbase] }.to raise_error SystemExit
-      should include '[!]'
-    end
+  end
+
+  context 'when routing commands' do
 
-    it 'routes `prepare`' do
-      Klipp.expects(:prepare)
-      Klipp.route *%w[prepare Example]
+    it 'returns exit code 1 without any commands and displays a hint' do
+      (capture_stdout do
+        Klipp.route(*%w[]).should eq 1
+      end).should include '[?]'
     end
 
-    it 'prints help when preparing without a template name' do
-      expect { Klipp.route *%w[prepare] }.to raise_error SystemExit
-      should include 'Add a template name to the `prepare` command.'
+    it 'returns exit code 1 with an unknown command and displays the error' do
+      (capture_stdout do
+        Klipp.route(*%w[magic]).should eq 1
+      end).should include '[!]'
     end
 
-    it 'routes `list`' do
-      Klipp.expects(:list)
-      Klipp.route *%w[list]
+    it 'routes prepare' do
+      Klipp.expects(:cli_prepare).with(['Example'])
+      Klipp.route(*%w[prepare Example])
     end
 
-    it 'routes `version`' do
-      Klipp.expects(:version)
-      Klipp.route *%w[version]
+    it 'routes create' do
+      Klipp.expects(:cli_create).with(['-f'])
+      Klipp.route(*%w[create -f])
     end
 
-    it 'routes `create``' do
-      Klipp.expects(:create)
-      Klipp.route *%w[create]
+    it 'routes template with exit code 0' do
+      Template.expects(:route)
+      Klipp.route(*%w[template]).should eq 0
     end
 
   end
 
-  describe 'when preparing' do
+  context 'prepare' do
 
     before do
-      Klipp::Configuration.stubs(:root_dir).returns File.join(__dir__, 'fixtures')
+      Klipp::Configuration.stubs(:root_dir).returns(File.join(__dir__, 'fixtures'))
     end
 
-    it 'raises help if the template argument is missing' do
-      expect { Klipp.prepare nil }.to raise_error HelpRequest
+    it 'without template name raises error' do
+      expect { Klipp.cli_prepare([]) }.to raise_error Klipp::Hint
     end
 
-    it 'saves a klippfile' do
-      IO.expects(:write).with('Example.klippfile', anything).once
-      Klipp.prepare 'Example'
-    end
+    context 'without an existing Klippfile' do
+      before do
+        File.stubs(:exists?).returns(false)
+      end
 
-    it 'raises an error when the template argument is incorrect' do
-      expect { Klipp.prepare 'Bullshit' }.to raise_error RuntimeError
+      it 'write a new Klippfile' do
+        klippfile = read_fixture 'Klippfile-after-prepare'
+        File.expects(:write).with('Klippfile', klippfile)
+        Klipp.cli_prepare(%w[Example])
+      end
     end
 
-    it 'raises an error when a .klippfile for the template already exists' do
-      File.stubs(:exists?).with(anything).returns true
-      expect { Klipp.prepare 'Example' }.to raise_error RuntimeError
-    end
 
-  end
+    context 'with an existing Klippfile' do
 
-  describe 'when listing' do
+      before do
+        File.stubs(:exists?).returns(true)
+      end
 
-    it 'lists templates' do
-      Klipp::Configuration.stubs(:root_dir).returns File.join(__dir__, 'fixtures')
-      Klipp.list
-      should include 'Example'
-    end
+      it 'will not overwrite' do
+        File.expects(:write).never
+        expect { Klipp.cli_prepare(%w[Example]) }.to raise_error RuntimeError
+      end
+
+      it 'will overwrite when forced' do
+        klippfile = read_fixture 'Klippfile-after-prepare'
+        File.expects(:write).with('Klippfile', klippfile)
+        Klipp.cli_prepare(%w[Example -f])
+      end
 
-    it 'raises an error when there are no templates' do
-      Klipp.expects(:template_files).returns([])
-      expect { Klipp.list }.to raise_error RuntimeError
     end
 
   end
 
-  describe 'when versioning' do
+  context 'create' do
 
-    it 'displays the current version' do
-      Klipp.version
-      should include Klipp::VERSION
+    before do
+      Klipp::Configuration.stubs(:root_dir).returns(File.join(__dir__, 'fixtures'))
+      Dir.stubs(:pwd).returns(Dir.mktmpdir)
+
+      maker = Klipp::Creator.new
+      maker.eval_string(read_fixture('Klippfile'), fixture_path('Klippfile'))
+      Klipp::Creator.stubs(:from_file).returns(maker)
     end
 
-  end
+    it 'creates files from a Klippfile' do
 
-  describe 'when creating' do
+      Klipp.cli_create([])
+      File.exists?(File.join Dir.pwd, 'Podfile').should be true
+      File.exists?(File.join Dir.pwd, '.gitignore').should be true
+      File.exists?(File.join Dir.pwd, 'AmazingApp').should be true
+      File.exists?(File.join Dir.pwd, 'Example.klippspec').should be false
 
-    before do
-      Klipp::Configuration.stubs(:root_dir).returns File.join(__dir__, 'fixtures')
-      @example_klippfile_contents = File.read(File.join(__dir__, 'fixtures', 'klipps', 'Example.klippfile'))
     end
 
-    it 'calls create on a project with a named template' do
-      mock_project = mock
-      mock_project.expects(:create)
-      Klipp::Project.expects(:new).with(is_a(Klipp::Template)).returns(mock_project)
-      File.stubs(:read).with(anything).returns( @example_klippfile_contents )
-      Klipp.create('Example')
-    end
+    it 'creates files interactively' do
 
-    it 'calls create on a project with an inferred template' do
-      Dir.expects(:glob).with(anything, anything).returns %w(Example.klippfile)
-      mock_project = mock
-      mock_project.expects(:create)
-      Klipp::Project.expects(:new).with(is_a(Klipp::Template)).returns(mock_project)
-      File.stubs(:read).with(anything).returns( @example_klippfile_contents )
-      Klipp.create nil
-    end
+      input = StringIO.new
+      output = StringIO.new
+      highline = HighLine.new(input, output)
 
-    it 'raises an error when the template name can\'t be inferred' do
-      Dir.expects(:glob).with(anything, anything).returns []
-      expect { Klipp.create nil }.to raise_error RuntimeError
-    end
+      input << "KLPObject\nN\n"
+      input.rewind
 
-  end
+      Klipp.cli_create(%w(Interactive), highline)
+      File.exists?(File.join Dir.pwd, 'KLPObjectTests.m').should be true
+
+    end
 
-  def subject
-    @output.string
   end
 
 end

data/spec/spec_helper.rb

@@ -7,11 +7,17 @@ SimpleCov.formatter = SimpleCov::Formatter::HTMLFormatter
 
 require 'klipp'
 
+def fixture_path fixture_name
+  Dir.glob(File.join(__dir__, 'fixtures', '**', fixture_name)).first
+end
+
 def read_fixture fixture_name
-  File.read(File.join(__dir__, 'fixtures', fixture_name))
+  File.read(fixture_path fixture_name)
 end
 
 RSpec.configure do |config|
   config.mock_framework = :mocha
   config.order = 'random'
-end
+end
+
+Klipp.env = StringInquirer.new('test')

data/spec/template/spec_spec.rb

@@ -0,0 +1,225 @@
+require 'spec_helper'
+
+describe Template::Spec do
+
+  context 'identifier methods' do
+
+    before do
+      Klipp::Configuration.stubs(:root_dir).returns(File.join(File.dirname(__dir__), 'fixtures'))
+    end
+
+    it 'finds the path to a template name' do
+      path = Template::Spec.spec_path_for_identifier('Example')
+      path.should eq File.join(File.dirname(__dir__), 'fixtures', 'template-repository', 'Example', 'Example.klippspec')
+    end
+
+    it 'raises error if a template doesn\'t exist' do
+      expect { Template::Spec.spec_path_for_identifier('Non-existing') }.to raise_error RuntimeError
+    end
+
+    it 'knows about unambiguous specs' do
+      Template::Spec.identifier_is_ambiguous('Ambiguous').should eq false
+    end
+
+    it 'raises error if a template is unambiguous' do
+      expect { Template::Spec.spec_path_for_identifier('Ambiguous') }.to raise_error RuntimeError, /Found multiple templates/
+    end
+
+    it 'finds the path to a template in a specific repo' do
+      path = Template::Spec.spec_path_for_identifier('template-repository/Ambiguous')
+      path.should eq File.join(File.dirname(__dir__), 'fixtures', 'template-repository', 'Ambiguous', 'Ambiguous.klippspec')
+    end
+
+    it 'deducts the template identifier from an unambiguous template name' do
+      path = Template::Spec.spec_path_for_identifier 'Example'
+      hash = Template::Spec.hash_for_spec_path path
+      Template::Spec.hash_to_identifier(hash).should eq 'template-repository/Example'
+    end
+
+  end
+
+  context 'with validation disabled' do
+    before do
+      Template::Spec.any_instance.stubs(:invalidate)
+    end
+
+    it 'yields on initialize' do
+      expect { |probe| Template::Spec.new().spec 'Example', &probe }.to yield_control
+    end
+
+    it 'passes itself as a parameter on yield' do
+      expect { |probe| Template::Spec.new().spec('Example', &probe) }.to yield_with_args(be_an_instance_of(Template::Spec))
+    end
+
+    it 'validates the spec after configuration' do
+      spec = Template::Spec.new
+      spec.expects(:validate_spec)
+      spec.spec('')
+    end
+
+    it 'raises an error when overwriting tokens, like the BLANK token' do
+      (expect do
+        Template::Spec.new().spec 'Example' do |spec|
+          spec.token :BLANK do |t|
+            t.comment = "You can't overwrite tokens"
+          end
+        end
+      end).to raise_error RuntimeError
+    end
+  end
+
+  context 'with an invalid spec' do
+
+    before do
+      @spec = Template::Spec.new
+    end
+
+    it 'invalidates' do
+      @spec.expects(:invalidate)
+      @spec.spec('')
+    end
+
+    it 'raises an error when invalidating' do
+      expect { @spec.spec('') }.to raise_error RuntimeError
+    end
+
+    it 'rescues and re-raises errors from the config block' do
+      expect { @spec.spec('Example') { |s| s.lala = 5 } }.to raise_error RuntimeError, /Invalid klippspec configuration/
+    end
+
+    it 'raises errors from klippspec string' do
+      expect { @spec.from_string('lalala', 'fake/path') }.to raise_error RuntimeError, /Error evaluating spec/
+    end
+
+  end
+
+  context 'with a valid spec' do
+
+    before do
+      @template = Template::Spec.new
+      @template.spec('Example') {}
+    end
+
+    it 'has a name' do
+      @template.identifier = 'repo/ProjectX'
+      @template.identifier.should eq 'repo/ProjectX'
+    end
+
+    it 'has a post-action setter' do
+      @template.post_action = 'pod install'
+      @template.post_actions.should eq ['pod install']
+    end
+
+    it 'has a post-actions setter' do
+      @template.post_actions = ['git init', 'git add .', 'git commit -m "Initial commit."', 'pod install']
+      @template.post_actions.should eq ['git init', 'git add .', 'git commit -m "Initial commit."', 'pod install']
+    end
+    it 'has a token hash' do
+      @template[:PROJECT_ID] = Template::Token.new
+      @template[:PROJECT_ID].should be_an_instance_of(Template::Token)
+    end
+
+    it 'creates a token' do
+      yielded_token = :not_a_token
+      @template.token(:PROJECT_ID) { |t| yielded_token = t }
+      yielded_token.should be_an_instance_of Template::Token
+    end
+
+    it 'has a blank token' do
+      @template[:BLANK].hidden.should eq true
+      @template[:BLANK].value.should eq ''
+    end
+
+    it 'has a date token' do
+      @template[:DATE].hidden.should eq true
+      @template[:DATE].value.should eq DateTime.now.strftime('%F')
+    end
+
+    it 'has a year token' do
+      @template[:YEAR].hidden.should eq true
+      @template[:YEAR].value.should eq '2013'
+    end
+
+  end
+
+  context 'when loading a klippspec' do
+
+    before do
+      Klipp::Configuration.stubs(:root_dir).returns(File.join(File.dirname(__dir__), 'fixtures'))
+    end
+
+    context 'with an invalid klippspec' do
+
+      it 'raises an error when loading an invalid klippspec' do
+        klippspec = File.join(Klipp::Configuration.root_dir, 'template-repository', 'BadExample', 'BadExample.klippspec')
+        File.exists?(klippspec).should be true
+        expect { Template::Spec.from_file(klippspec) }.to raise_error RuntimeError
+      end
+
+    end
+
+    context 'with a valid klippspec' do
+
+      before do
+        @path = File.join(Klipp::Configuration.root_dir, 'template-repository', 'Example', 'Example.klippspec')
+        File.exists?(@path).should be true
+
+        @spec = Template::Spec.from_file(@path)
+      end
+
+      it 'loads a spec from a file' do
+        @spec.should be_an_instance_of Template::Spec
+      end
+
+      it 'generates a project specific Klippfile' do
+        fixture = read_fixture 'Klippfile-after-prepare'
+        @spec.klippfile.should eq fixture
+      end
+
+      it 'references the repo in the Klippfile' do
+        @spec.klippfile.should include 'template-repository/Example'
+      end
+
+      context 'with a values hash' do
+        before do
+          @values = Hash.new
+          @values[:PROJECT_ID] = "Klipp"
+          @values[:PROJECT_TITLE] = "Templates for the rest of us"
+          @values[:BUNDLE_ID] = "com.epologee.klipp"
+          @values[:ORGANIZATION_NAME] = "epologee"
+          @values[:CLASS_PREFIX] = "KLP"
+          @values[:SECRET_TOGGLE] = true
+        end
+
+        it 'validates token values' do
+          @spec.set_token_values @values
+        end
+
+        it 'replaces delimited tokens with its values' do
+          @spec.set_token_values @values
+          source = 'XXPROJECT_IDXX - XXPROJECT_TITLEXX - XXBUNDLE_IDXX - XXORGANIZATION_NAMEXX - XXCLASS_PREFIXXX - XXSECRET_TOGGLEXX - [XXBLANKXX]'
+          target = 'Klipp - Templates for the rest of us - com.epologee.klipp - epologee - KLP - YES - []'
+          @spec.replace_tokens(source).should eq target
+        end
+      end
+
+
+    end
+
+  end
+
+  context 'when creating a klippspec' do
+
+    before do
+      Klipp::Configuration.stubs(:root_dir).returns(File.join(File.dirname(__dir__), 'fixtures'))
+    end
+
+    it 'generates the klippspec' do
+      spec = Template::Spec.new
+      spec.identifier = 'Another-Template'
+      spec.klippspec.should eq read_fixture('Another-Template.klippspec')
+    end
+
+  end
+
+end

data/spec/template/token_spec.rb

@@ -0,0 +1,100 @@
+require 'spec_helper'
+
+describe Template::Token do
+
+  before do
+    @token = Template::Token.new
+  end
+
+  it 'has a default string type' do
+    @token.type.should eq :string
+  end
+
+  it 'will not allow an unknown type' do
+    expect { @token.type = :invalid_type }.to raise_error RuntimeError
+  end
+
+  context 'with type string' do
+
+    it 'has a hidden property' do
+      @token.hidden = true
+      @token.hidden.should eq true
+    end
+
+    it 'is not hidden by default' do
+      @token.hidden.should eq false
+    end
+
+    it 'has a comment' do
+      @token.comment = 'Comment'
+      @token.comment.should eq 'Comment'
+    end
+
+    it 'has a validation' do
+      @token.validation = /^[A-Z][A-Za-z0-9]{2,}$/
+      @token.validation.should eq /^[A-Z][A-Za-z0-9]{2,}$/
+    end
+
+    it 'has a default validation hint' do
+      @token.validation = /^[A-Z][A-Za-z0-9]{2,}$/
+      @token.validation_hint.should include '(no custom validation_hint given)'
+    end
+
+    it 'accepts custom validation hints' do
+      @token.validation_hint = 'Hint'
+      @token.validation_hint.should eq 'Hint'
+    end
+
+    it 'invalidates booleans assigned' do
+      expect { @token.value = true }.to raise_error RuntimeError
+    end
+
+  end
+
+  context 'with type bool' do
+
+    before do
+      @token.type = :bool
+    end
+
+    it 'accepts boolean values' do
+      @token.value = true
+      @token.value.should eq true
+
+      @token.value = false
+      @token.value.should eq false
+    end
+
+    it 'accepts booleans as strings' do
+      @token.value = 'true'
+      @token.value.should eq true
+
+      @token.value = 'yes'
+      @token.value.should eq true
+
+      @token.value = 'Yes'
+      @token.value.should eq true
+
+      @token.value = 'y'
+      @token.value.should eq true
+
+      @token.value = 'false'
+      @token.value.should eq false
+
+      @token.value = 'no'
+      @token.value.should eq false
+
+      @token.value = 'No'
+      @token.value.should eq false
+
+      @token.value = 'n'
+      @token.value.should eq false
+    end
+
+    it 'invalidates other strings' do
+      expect { @token.value = 'ja' }.to raise_error RuntimeError
+    end
+
+  end
+
+end