redmint_composer 2.3

data/spec/rails_wizard/recipe_spec.rb

@@ -0,0 +1,115 @@
+require 'spec_helper'
+
+describe RailsWizard::Recipe do
+  context "with a generated recipe" do
+    subject{ RailsWizard::Recipe.generate('recipe_example', "# this is a test", :category => 'example', :name => "RailsWizard Example") }
+
+    context 'string setter methods' do
+      (RailsWizard::Recipe::ATTRIBUTES - ['config']).each do |setter|
+        it "should be able to set #{setter} with an argument" do
+          subject.send(setter + '=', "test")
+          subject.send(setter).should == 'test'
+        end
+
+        it 'should be able to get the value from the instance' do
+          subject.send(setter + '=', 'test')
+          subject.new.send(setter).should == subject.send(setter)
+        end
+      end
+    end
+
+    describe '.attributes' do
+      it 'should be accessible from the instance' do
+        subject.new.attributes.should == subject.attributes
+      end
+    end
+
+    describe '.generate' do
+      it 'should work with a string and hash as arguments' do
+        recipe = RailsWizard::Recipe.generate('some_key', '# some code', :name => "Example")
+        recipe.superclass.should == RailsWizard::Recipe
+      end
+
+      it 'should work with an IO object' do
+        file = StringIO.new <<-RUBY
+# this is an example
+
+__END__
+
+category: example
+name: This is an Example
+description: You know it's an exmaple.
+RUBY
+        recipe = RailsWizard::Recipe.generate('just_a_test', file)
+        recipe.template.should == '# this is an example'
+        recipe.category.should == 'example'
+        recipe.name.should == 'This is an Example'
+      end
+
+      it 'should raise an exception if the file is incorrectly formatted' do
+        file = StringIO.new <<-RUBY
+# just ruby, no YAML
+RUBY
+        lambda{RailsWizard::Recipe.generate('testing',file)}.should raise_error(ArgumentError)
+      end
+    end
+
+    describe '#compile' do
+      it 'should say the name' do
+        subject.name = "Awesome Sauce"
+        subject.new.compile.should be_include("say_recipe 'Awesome Sauce'")
+      end
+
+      it 'should include the template' do
+        subject.template = "This is only a test."
+        subject.new.compile.should be_include(subject.template)
+      end
+    end
+  end
+
+  it 'should set default attributes' do
+    recipe = RailsWizard::Recipe.generate('abc','# test')
+
+    RailsWizard::Recipe::DEFAULT_ATTRIBUTES.each_pair do |k,v|
+      recipe.send(k).should == v
+    end
+  end
+
+  describe ".from_mongo" do
+    context "when asked for a known recipe" do
+      before(:all) do
+        @recipe_key = 'recipe_example'
+        @recipe = RailsWizard::Recipe.generate(@recipe_key, '# this is a test', {
+            :category => 'example',
+            :name     => 'RailsWizard Example',
+            } )
+        RailsWizard::Recipes.add(@recipe)
+        @recipe_klass = Kernel.
+            const_get('RailsWizard'  ).
+            const_get('Recipes'      ).
+            const_get('RecipeExample')
+      end
+
+      context "by key" do
+        it "returns the recipe" do
+          RailsWizard::Recipe.from_mongo(@recipe_key).should == @recipe_klass
+        end
+      end
+      context "by class" do
+        it "returns the recipe" do
+          RailsWizard::Recipe.from_mongo(@recipe_klass).should == @recipe_klass
+        end
+      end
+    end
+
+    context "when asked for an unknown recipe" do
+      it "raises an UnknownRecipeError" do
+        expect { RailsWizard::Recipe.from_mongo("foo") }.to raise_error RailsWizard::UnknownRecipeError, "No recipe found with name 'foo'"
+      end
+    end
+  end
+end
+
+__END__
+
+this is a test

data/spec/rails_wizard/recipes/sanity_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+# This is a simple set of tests to make sure that
+# all of the recipes conform to the base requirements.
+
+RailsWizard::Recipes.list_classes.each do |recipe|
+  describe recipe do
+    it("should have a name"){ recipe.name.should be_kind_of(String) }    
+    it("should have a description"){ recipe.description.should be_kind_of(String) }
+    it("should have a template"){ recipe.template.should be_kind_of(String) }
+    it("should be able to compile"){ recipe.new.compile.should be_kind_of(String) }
+    
+    it "should have a string or nil category" do
+      if recipe.category
+        recipe.category.should be_kind_of(String)
+      end
+    end
+
+    it "should have a Config or nil config" do
+      if recipe.config
+        recipe.config.should be_kind_of(RailsWizard::Config)
+      end
+    end
+
+    it "should be in the list" do
+      RailsWizard::Recipes.list_classes.should be_include(recipe)
+      RailsWizard::Recipes.list.should be_include(recipe.key)
+    end
+  end
+end

data/spec/rails_wizard/recipes_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe RailsWizard::Recipes do
+  subject{ RailsWizard::Recipes }
+
+  before(:all) do
+    @recipe = RailsWizard::Recipe.generate( "recipe_test", "# Testing", {
+        :category    =>        'test',
+        :description => 'Just a test.',
+        :name        =>        'Test Recipe',
+        } )
+    RailsWizard::Recipes.add(@recipe)
+  end
+
+  it '.list_classes should include recipe classes' do
+    subject.list_classes.should be_include(@recipe)
+  end
+
+  it '.list should include recipe keys' do
+    subject.list.should be_include('recipe_test')
+  end
+
+  describe '.for' do
+    it 'should find for a given category' do
+      RailsWizard::Recipes.for('test').should be_include('recipe_test')
+    end
+  end
+
+  it 'should add recipes in a directory with add_from_directory' do
+    subject.add_from_directory(File.join(File.dirname(__FILE__), '..', 'test_recipes'))
+    subject.list.should include 'test_recipe_in_file'
+  end
+
+  describe '.clear' do
+    it 'should remove all current recipes' do
+      RailsWizard::Recipes.clear
+      subject.list.should == []
+      subject.categories.should == []
+    end
+  end
+end

data/spec/rails_wizard/template_spec.rb

@@ -0,0 +1,92 @@
+require 'spec_helper'
+
+describe RailsWizard::Template do
+  subject{ RailsWizard::Template }
+  let(:recipe){ RailsWizard::Recipe.generate('name','# test') }
+  let(:defaults){ { "some_option" => "value" } }
+  let(:gems){ ['foogem'] }
+  let(:args){ [] }
+
+  describe '.template_root' do
+    it 'returns the gem ./templates directory by default' do
+      template_root = File.expand_path(subject.template_root)
+      template_root.should == File.expand_path('../../../templates', __FILE__)
+    end
+
+    it 'can be set to another directory' do
+      subject.template_root = '/tmp/templates'
+      subject.template_root.should == '/tmp/templates'
+    end
+  end
+
+  describe '#initialize' do
+    it 'should work with classes' do
+      subject.new([recipe], gems).recipes.should == [recipe]
+    end
+
+    it 'should accept optional defaults' do
+      subject.new([recipe], gems, args, defaults).defaults.should == defaults
+    end
+  end
+
+  describe '#resolve_dependencies' do
+    def recipe(name, opts={})
+      RailsWizard::Recipe.generate(name, '', opts)
+    end
+
+    subject do
+      @template = RailsWizard::Template.new([])
+      @template.stub(:recipes_with_dependencies).and_return(@recipes)
+      @template.resolve_recipes.map { |r| r.key }
+    end
+
+    it 'should sort properly' do
+      @recipes = [
+        recipe('add_user', :run_after => ['devise']),
+        recipe('devise', :run_after => ['omniauth']),
+        recipe('omniauth'),
+        recipe('haml'),
+        recipe('compass')
+      ]
+
+      subject.index('devise').should > subject.index('omniauth')
+    end
+
+  end
+
+  describe '#recipes_with_dependencies' do
+    def r(*deps)
+      double(:Class, :requires => deps, :superclass => RailsWizard::Recipe)
+    end
+
+    subject do
+      @template = RailsWizard::Template.new([])
+      @template.stub(:recipes).and_return(@recipes)
+      @template.stub(:recipe_classes).and_return(@recipes)
+      @template
+    end
+
+    it 'should return the same number recipes if none have dependencies' do
+      @recipes = [r, r]
+      subject.recipes_with_dependencies.size.should == 2
+    end
+
+    it 'should handle simple dependencies' do
+      @recipes = [r(r, r), r(r)]
+      subject.recipes_with_dependencies.size.should == 5
+    end
+
+    it 'should handle multi-level dependencies' do
+      @recipes = [r(r(r))]
+      subject.recipes_with_dependencies.size.should == 3
+    end
+
+    it 'should uniqify' do
+      a = r
+      b = r(a)
+      c = r(r, a, b)
+      @recipes = [a,b,c]
+      subject.recipes_with_dependencies.size.should == 4
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+require 'bundler'
+Bundler.setup
+require 'rspec'
+
+Dir[File.dirname(__FILE__) + '/support/*'].each{|path| require path}
+
+require 'rails_wizard'
+
+RSpec.configure do |config|
+
+end

data/spec/support/rails_directory.rb

@@ -0,0 +1,17 @@
+class RailsDirectory
+  def initialize(path)
+    @path = path
+  end
+
+  def file_path(path)
+    File.join(@path, path)
+  end
+
+  def has_file?(path)
+    File.exist?(file_path(path))
+  end
+
+  def [](path)
+    File.open(file_path(path)).read
+  end
+end

data/spec/support/template_runner.rb

@@ -0,0 +1,28 @@
+class TemplateRunner
+  attr_reader :template, :config, :app_name, :dir, :rails_dir, :output
+  def initialize(template, config)
+    @template = template
+    @config = config
+  end
+
+  def run(app_name = 'rails_app')
+    @app_name = app_name
+    @dir = Dir.mktmpdir
+    @rails_dir = File.join(@dir, @app_name)
+    Dir.chrdir(@dir) do
+      template_file = File.open 'template.rb', 'w'
+      template_file.write
+      template_file.close
+      @output = `rails new #{@app_name} -m template.rb`
+    end
+    @output
+  end
+
+  def rails
+    RailsDirectory.new(@rails_dir)
+  end
+
+  def clean
+    FileUtils.remove_entry_secure @dir
+  end
+end

data/spec/test_recipes/test_recipe_in_file.rb

@@ -0,0 +1,9 @@
+say_wizard "Hi! I am a test."
+
+__END__
+
+name: test_recipe_in_file
+description: "this is test file"
+author: githubname
+
+category: test

data/templates/helpers.erb

@@ -0,0 +1,138 @@
+def recipes; @recipes end
+def recipe?(name); @recipes.include?(name) end
+def prefs; @prefs end
+def prefer(key, value); @prefs[key].eql? value end
+def gems; @gems end
+def diagnostics_recipes; @diagnostics_recipes end
+def diagnostics_prefs; @diagnostics_prefs end
+
+def say_custom(tag, text); say "\033[1m\033[36m" + tag.to_s.rjust(10) + "\033[0m" + "  #{text}" end
+def say_loud(tag, text); say "\033[1m\033[36m" + tag.to_s.rjust(10) + "  #{text}" + "\033[0m" end
+def say_recipe(name); say "\033[1m\033[36m" + "recipe".rjust(10) + "\033[0m" + "  Running #{name} recipe..." end
+def say_wizard(text); say_custom(@current_recipe || 'composer', text) end
+
+def ask_wizard(question)
+  ask "\033[1m\033[36m" + ("option").rjust(10) + "\033[1m\033[36m" + "  #{question}\033[0m"
+end
+
+def whisper_ask_wizard(question)
+  ask "\033[1m\033[36m" + ("choose").rjust(10) + "\033[0m" + "  #{question}"
+end
+
+def yes_wizard?(question)
+  answer = ask_wizard(question + " \033[33m(y/n)\033[0m")
+  case answer.downcase
+    when "yes", "y"
+      true
+    when "no", "n"
+      false
+    else
+      yes_wizard?(question)
+  end
+end
+
+def no_wizard?(question); !yes_wizard?(question) end
+
+def multiple_choice(question, choices)
+  say_custom('option', "\033[1m\033[36m" + "#{question}\033[0m")
+  values = {}
+  choices.each_with_index do |choice,i|
+    values[(i + 1).to_s] = choice[1]
+    say_custom( (i + 1).to_s + ')', choice[0] )
+  end
+  answer = whisper_ask_wizard("Enter your selection:") while !values.keys.include?(answer)
+  values[answer]
+end
+
+@current_recipe = nil
+@configs = {}
+
+@after_blocks = []
+def stage_two(&block); @after_blocks << [@current_recipe, block]; end
+@stage_three_blocks = []
+def stage_three(&block); @stage_three_blocks << [@current_recipe, block]; end
+@stage_four_blocks = []
+def stage_four(&block); @stage_four_blocks << [@current_recipe, block]; end
+@before_configs = {}
+def before_config(&block); @before_configs[@current_recipe] = block; end
+
+def copy_from(source, destination)
+  begin
+    remove_file destination
+    get source, destination
+  rescue OpenURI::HTTPError
+    say_wizard "Unable to obtain #{source}"
+  end
+end
+
+def copy_from_repo(filename, opts = {})
+  repo = 'https://raw.github.com/RailsApps/rails-composer/master/files/'
+  repo = opts[:repo] unless opts[:repo].nil?
+  if (!opts[:prefs].nil?) && (!prefs.has_value? opts[:prefs])
+    return
+  end
+  source_filename = filename
+  destination_filename = filename
+  unless opts[:prefs].nil?
+    if filename.include? opts[:prefs]
+      destination_filename = filename.gsub(/\-#{opts[:prefs]}/, '')
+    end
+  end
+  if (prefer :templates, 'haml') && (filename.include? 'views')
+    remove_file destination_filename
+    destination_filename = destination_filename.gsub(/.erb/, '.haml')
+  end
+  if (prefer :templates, 'slim') && (filename.include? 'views')
+    remove_file destination_filename
+    destination_filename = destination_filename.gsub(/.erb/, '.slim')
+  end
+  begin
+    remove_file destination_filename
+    if (prefer :templates, 'haml') && (filename.include? 'views')
+      create_file destination_filename, html_to_haml(repo + source_filename)
+    elsif (prefer :templates, 'slim') && (filename.include? 'views')
+      create_file destination_filename, html_to_slim(repo + source_filename)
+    else
+      get repo + source_filename, destination_filename
+    end
+  rescue OpenURI::HTTPError
+    say_wizard "Unable to obtain #{source_filename} from the repo #{repo}"
+  end
+end
+
+def html_to_haml(source)
+  begin
+    html = open(source) {|input| input.binmode.read }
+    Html2haml::HTML.new(html, :erb => true, :xhtml => true).render
+  rescue RubyParser::SyntaxError
+    say_wizard "Ignoring RubyParser::SyntaxError"
+    # special case to accommodate https://github.com/RailsApps/rails-composer/issues/55
+    html = open(source) {|input| input.binmode.read }
+    say_wizard "applying patch" if html.include? 'card_month'
+    say_wizard "applying patch" if html.include? 'card_year'
+    html = html.gsub(/, {add_month_numbers: true}, {name: nil, id: "card_month"}/, '')
+    html = html.gsub(/, {start_year: Date\.today\.year, end_year: Date\.today\.year\+10}, {name: nil, id: "card_year"}/, '')
+    result = Html2haml::HTML.new(html, :erb => true, :xhtml => true).render
+    result = result.gsub(/select_month nil/, "select_month nil, {add_month_numbers: true}, {name: nil, id: \"card_month\"}")
+    result = result.gsub(/select_year nil/, "select_year nil, {start_year: Date.today.year, end_year: Date.today.year+10}, {name: nil, id: \"card_year\"}")
+  end
+end
+
+def html_to_slim(source)
+  html = open(source) {|input| input.binmode.read }
+  haml = Html2haml::HTML.new(html, :erb => true, :xhtml => true).render
+  Haml2Slim.convert!(haml)
+end
+
+# full credit to @mislav in this StackOverflow answer for the #which() method:
+# - http://stackoverflow.com/a/5471032
+def which(cmd)
+  exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
+  ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
+    exts.each do |ext|
+    exe = "#{path}#{File::SEPARATOR}#{cmd}#{ext}"
+      return exe if File.executable? exe
+    end
+  end
+  return nil
+end