eldarscrolls 0.7.0

data/.gitignore

@@ -0,0 +1,8 @@
+*.gem
+.bundle
+Gemfile.lock
+./test_run
+dist/*
+.idea
+.rvmrc
+

data/.rspec

@@ -0,0 +1,2 @@
+--format=progress
+--colour

data/.travis.yml

@@ -0,0 +1,6 @@
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - jruby
+  - rbx
+  - ree

data/ChangeLog.md

@@ -0,0 +1,63 @@
+# ChangeLog
+
+New
+
+* `split` - AB testing promoed in RailsCasts
+* `spork` - clean running of tests
+* `resque` - always includes admin dashboard
+
+Fixed
+
+* `cucumber` - creates databases before running installer
+
+Internal
+
+* Replace ZenTest with Guard
+* Add 'rake list:categories' task
+
+## v0.6
+
+* `twitter_bootstrap` - automatically includes `simple_form`; includes flash msg
+* `github` - asks for a new repo name if cannot create a repository
+* `rails_basics` - default flash message
+* `jquery` & `prototype` - former is already default in Rails 3.1+ now
+
+New
+* `guard` - guard support for all supported scrolls
+* `postgresql`
+* All untested scrolls moved into scrolls/zzz
+
+## v0.5
+
+* `twitter_bootstrap` - based on public RailsCast
+* `eycloud` - now using `ey_cli` to create/boot environments
+
+## v0.4
+
+* SCROLLS ARE IN, "recipes" are out. Wizards use scrolls. Alchemists use recipes.
+* Scrolls have no dependencies on `eycloud` or `eycloud_recipes_on_deploy`; these are optional
+* `github` - GitHub repository creation
+* `resque` + `delayed_job` can install their admin consoles
+* `sidekiq` - high performance, low cost alternative to `resque` or `delayed_job`
+
+## v0.3
+
+* Engine Yard support - Resque
+* Removed a bunch of recipes that didn't see useful/common
+
+### v0.3.1
+
+* Resque recipe works a treat.
+
+Try this on EY Cloud! `eldarscrolls new demomysql -r sqlite3 mysql resque rails_basics git`
+
+## v0.2
+
+Merged lots of branches/forks
+
+## v0.2.1
+
+* Cleaned up many recipes
+* Added :website attribute to recipes
+* Convert all recipes to use supported categories
+

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

data/Guardfile

@@ -0,0 +1,18 @@
+guard 'cucumber' do
+  watch(%r{^features/.+\.feature$})
+  watch(%r{^features/support/.+$})          { 'features' }
+  watch(%r{^features/step_definitions/(.+)_steps\.rb$}) { |m| Dir[File.join("**/#{m[1]}.feature")][0] || 'features' }
+end
+
+guard 'rspec', :version => 2 do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^scrolls/(.+)\.rb$})     { |m| "spec/eldarscrolls/scrolls/sanity_spec.rb" }
+  watch(%r{^lib/eldarscrolls/(.+)\.rb$})     { |m| "spec/eldarscrolls/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end
+
+guard 'bundler' do
+  watch('Gemfile')
+  watch(/^.+\.gemspec/)
+end
+

data/MIT_LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Dr Nic Williams and Engine Yard LLC
+Copyright (c) 2010 Michael Bleigh and Intridea, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,157 @@
+# The Eldar Scrolls for creating and transforming Rails apps
+
+```
+   ______   __           ____             ____  
+  / __/ /__/ /__ _____  / __/__________  / / /__
+ / _// / _  / _ `/ __/ _\ \/ __/ __/ _ \/ / (_-<
+/___/_/\_,_/\_,_/_/   /___/\__/_/  \___/_/_/___/
+```
+
+The Eldar Scrolls is a magical tool to generate new Rails and modify existing Rails applications (coming) to include your favourite, powerful magic. Authentication, testing, persistence, javascript, css, deployment, and templating - there's a magical scroll for you.
+
+* Follow on twitter [@eldarscrolls][9]
+
+An example application that was built by the Eldar Scrolls is at [https://github.com/drnic/mydemoapp][14]. The generated README shows all the scrolls that were included.
+
+## Installation
+
+Installation is simple:
+
+    gem install eldarscrolls
+
+## Usage
+
+The primary usage of the `eldarscrolls` gem is to utilize its interactive terminal command to build a new Rails application. To get started, you can simply run the command thusly:
+
+    eldar new APP_NAME
+    eldarscrolls new APP_NAME
+
+Where `APP_NAME` is the directory in which you wish to create the app (it mirrors the Rails creation syntax). You will then be guided through the scroll selection process and subsequently the Rails app generator will automatically run with the template and all appropriate command line options included.
+
+To transform an existing Rails app, you ... wait, that's not implemented yet. But since the "apply template" feature of `rails new APP_NAME -m template.rb` is implemented in Thor, I mean, how hard could it be?*
+
+### Specifying Scrolls
+
+If you wish to skip the interactive scroll selector, you may provide instead a list of scrolls with the `-s` or `--scrolls` option:
+
+    eldar new APP_NAME -s twitter_bootstrap mysql resque
+    eldar new APP_NAME --scrolls postgresql github eycloud
+
+This will automatically generate a Rails template with the provided scrolls and begin the app generator.
+
+### Listing Scrolls
+
+You can also print out a simple list of scrolls:
+
+    eldar list
+
+Or print out a list of scrolls for a specific category:
+
+    eldar list persistence
+
+## Deployment Support
+
+Web applications are boring if they aren't running proudly on the internet. The Eldar Scrolls make this automatic for your favourite providers!
+
+### Engine Yard
+
+Scroll: `eycloud`
+
+If you choose the `eycloud` scroll, your application will be automatically deployed to [Engine Yard Cloud][6]. Your code will also be automatically stored on a private/public GitHub repository.
+
+The `eycloud` scroll magically transforms many other scrolls to work specifically for [Engine Yard Cloud][6]. For example:
+
+* `postgresql` - the environment will have PostgreSQL selected instead of MySQL
+* `resque` - the environment will have Resque and Redis
+
+### Heroku
+
+The Eldar Scrolls needs a Heroku Master to support Heroku for the Eldar Scrolls. 
+
+There is some initial work in the [current scrolls][11] and the [archived/unsupported scrolls][12]
+
+### CloudFoundry
+
+The Eldar Scrolls needs a CloudFoundry Master to support CloudFoundry for the Eldar Scrolls. 
+
+## Authoring Scrolls of Magical Mystery
+
+Create new scrolls using:
+
+    rake new NAME=scroll-name
+
+Submitting a scroll is actually a very straightforward process. Scrolls are made of up **template code** and **YAML back-matter** stored in a ruby file. The `__END__` parsing convention is used so that each scroll is actually a valid, parseable Ruby file. The structure of a scroll looks something like this:
+
+```ruby
+gem 'supergem'
+
+after_bundler do
+  generate "supergem:install"
+end
+
+__END__
+
+category: templating
+name: SuperGem
+description: Installs SuperGem which is useful for things
+author: mbleigh
+```
+
+It's really that simple. The gem has RSpec tests that automatically validate each scroll in the repository, so you should run `rake spec` as a basic sanity check before submitting a pull request. Note that these don't verify that your scroll code itself works, just that Eldar Scrolls could properly parse and understand your scroll file.
+
+## History
+
+This project is an old fashioned fork of [Michael Bleigh][5]'s [Rails Wizard][4]. A new name, new project, and new purpose. 
+
+This project wouldn't exist without Michael having created [Rails Wizard][4] during Rails Rumble and maintaining and upgrading it for a long time. Sadly support dropped off, several recipes did not work with Rails 3.1+, 
+
+[Dr Nic][7] originally worked on [Rails Wizard][4] to provide [Engine Yard Cloud][6] support, his employer and his favourite hosting platform. He also merged in a lot of recipes from other forks, and added new recipes for modern projects.
+
+Support for Engine Yard Cloud meant integration with Chef Recipes. This meant confusing language - Rails Wizard Recipes and Chef Recipes. He decided that wizards don't use recipes - they use scrolls. Alchemists use recipes. And screw alchemists and their dinky potions. Recipes became Scrolls.
+
+"Eldar Scrolls" is a deliberate misspelling of the popular [Elder Scrolls][8] computer game. Ok, it was accidental but "eldarscrolls" and "eldarscrolls" should now be much easier to search for on Twitter and Google; and [@eldarscrolls][9] [eldarscrolls.org][1] were available
+
+## Future
+
+* Automatically setup Continuous Integration for new applications - branches "jenkins"
+* Interactive mode is a wizard by categories "pick A, B, C or none"
+* Apply scrolls to existing Rails applications - branch "[apply_scrolls][13]"*
+* Scrolls work or fail fast on Heroku
+* Scrolls work or fail fast on CloudFoundry
+* Scrolls generate their own README - branch "readmes"
+* 3rd party services/add-ons enabled within deployment platform or directly with service
+* Padrino / Sinatra applications
+* Non-Ruby applications (Lithium for PHP, etc)
+
+Missing scrolls
+
+* MongoDB - branch "mongodb"
+* OmniAuth - branch "omniauth"
+* Sidekiq - branch "sidekiq"
+
+How hard could it be?
+
+* `*` 'How hard could it be to transform applications?' - pretty hard. Scrolls need to be aware of the current code base, rather than merely the list of other scrolls being used to create a new app. Scrolls also need to know about versions of Rails rather than just latest rails.
+
+## Thanks
+
+ASCII banner - http://www.network-science.de/ascii/ using 'smslant' font.
+
+## License
+
+Eldar Scrolls and its scrolls are distributed under the MIT License. See [MIT_LICENSE][10] for the actual words.
+
+[1]:http://eldarscrolls.org/
+[2]:https://github.com/drnic/eldarscrolls
+[2]:https://github.com/drnic/eldarscrolls/tree/master/scrolls
+[4]:https://github.com/intridea/rails_wizard
+[5]:https://github.com/mbleigh
+[6]:http://www.engineyard.com/products/cloud
+[7]:http://drnicwilliams.com
+[8]:http://www.elderscrolls.com/
+[9]:https://twitter.com/elderscrolls
+[10]:https://github.com/drnic/eldarscrolls/blob/master/MIT_LICENSE
+[11]:https://github.com/drnic/eldarscrolls/tree/master/scrolls
+[12]:https://github.com/drnic/eldarscrolls/tree/master/scrolls/zzz
+[13]:https://github.com/drnic/eldarscrolls/tree/apply_scrolls
+[14]:https://github.com/drnic/mydemoapp

data/Rakefile

@@ -0,0 +1,78 @@
+require "bundler/gem_tasks"
+
+require 'rspec/core/rake_task'
+
+desc "run specs"
+RSpec::Core::RakeTask.new
+
+task :default => :spec
+
+
+desc "Remove the test_run Rails app (if it's there)"
+task :clean do
+  system 'rm -rf test_run'
+end
+
+desc "Execute a test run with the specified scrolls."
+task :run => :clean do
+  scrolls = ENV['SCROLLS'].split(',')
+
+  require 'tempfile'
+  require 'eldarscrolls'
+
+  template = EldarScrolls::Template.new(scrolls)
+
+  begin
+    dir = Dir.mktmpdir "rails_template"
+    Dir.chdir(dir) do
+      file = File.open('template.rb', 'w')
+      file.write template.compile
+      file.close  
+    
+      system "rails new test_run -m template.rb #{template.args.join(' ')}"
+
+      puts "\n\n cd #{dir} # look at the app"
+      puts "#{ENV['EDITOR']} #{dir} # edit the app"
+    end
+  end
+end
+
+desc "Prints out a template from the provided scrolls."
+task :print do
+  require 'eldarscrolls'
+
+  scrolls = ENV['SCROLLS'].split(',')
+  puts EldarScrolls::Template.new(scrolls).compile
+end
+
+desc "Create a new scroll"
+task :new do
+  unless (name = ENV['NAME']) && name.size > 0
+    $stderr.puts "USAGE: rake new NAME=scroll-name"
+    exit 1
+  end
+  require 'active_support/inflector'
+  require 'erb'
+  require 'eldarscrolls/template'
+  scroll = EldarScrolls::Template.render("new_scroll", binding)
+  scroll_path = "scrolls/#{name}.rb"
+  File.open(scroll_path, "w") { |file| file << scroll }
+  `open #{scroll_path}`
+end
+
+namespace :list do
+  desc "Display scrolls by category"
+  task :categories do
+    require 'eldarscrolls'
+    categories = EldarScrolls::Scrolls.categories.sort
+    categories = (categories - ["other"]) + ["other"]
+    categories.each do |category|
+      puts "#{category}: #{EldarScrolls::Scrolls.for(category).join(", ")}"
+    end
+  end
+
+  # desc "Display scrolls by exclusion"
+  # task :exclusions do
+  # 
+  # end
+end

data/bin/eldar

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+$:.push File.dirname(__FILE__) + '/../lib'
+
+require 'rubygems'
+require 'eldarscrolls/command'
+
+EldarScrolls::Command.start

data/bin/eldarscrolls

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+$:.push File.dirname(__FILE__) + '/../lib'
+
+require 'rubygems'
+require 'eldarscrolls/command'
+
+EldarScrolls::Command.start

data/eldarscrolls.gemspec

@@ -0,0 +1,32 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require File.dirname(__FILE__) + "/version"
+
+Gem::Specification.new do |s|
+  s.name        = "eldarscrolls"
+  s.version     = EldarScrolls::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Michael Bleigh", "Dr Nic Williams"]
+  s.email       = ["michael@intridea.com", "drnicwilliams@gmail.com"]
+  s.homepage    = "http://eldarscrolls.org/"
+  s.summary     = %q{The Eldar Scrolls is a magical tool to generate new Rails and modify existing Rails applications (coming) to include your favourite, powerful magic. }
+  s.description = %q{The Eldar Scrolls is a magical tool to generate new Rails and modify existing Rails applications (coming) to include your favourite, powerful magic. }
+
+  s.add_dependency "i18n"
+  s.add_dependency "json", "1.6.5"
+  s.add_dependency "activesupport", "~> 3.0"
+  s.add_dependency "thor"
+  s.add_development_dependency "rspec", "~> 2.5.0"
+  s.add_development_dependency "guard-rspec"
+  s.add_development_dependency "cucumber"
+  s.add_development_dependency "guard-cucumber"
+  s.add_development_dependency "bundler", "~> 1.1.0"
+  s.add_development_dependency "guard-bundler"
+  s.add_development_dependency "rails", "~> 3.0"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end
+

data/features/step_definitions/common_steps.rb

@@ -0,0 +1,211 @@
+Given /^this project is active project folder/ do
+  @active_project_folder = File.expand_path(File.dirname(__FILE__) + "/../..")
+end
+
+Given /^env variable \$([\w_]+) set to( project path|) "(.*)"/ do |env_var, path, value|
+  in_project_folder {
+    value = File.expand_path(value)
+  } unless path.empty?
+  ENV[env_var] = value
+end
+
+Given /"(.*)" folder is deleted/ do |folder|
+  in_project_folder { FileUtils.rm_rf folder }
+end
+
+When /^I invoke "(.*)" generator with arguments "(.*)"$/ do |generator, arguments|
+  @stdout = StringIO.new
+  in_project_folder do
+    if Object.const_defined?("APP_ROOT")
+      APP_ROOT.replace(FileUtils.pwd)
+    else
+      APP_ROOT = FileUtils.pwd
+    end
+    run_generator(generator, arguments.split(' '), SOURCES, :stdout => @stdout)
+  end
+  File.open(File.join(@tmp_root, "generator.out"), "w") do |f|
+    @stdout.rewind
+    f << @stdout.read
+  end
+end
+
+When /^I run executable "(.*)" with arguments "(.*)"/ do |executable, arguments|
+  @stdout = File.expand_path(File.join(@tmp_root, "executable.out"))
+  in_project_folder do
+    system "#{executable.inspect} #{arguments} > #{@stdout.inspect} 2> #{@stdout.inspect}"
+  end
+end
+
+When /^I run project executable "(.*)" with arguments "(.*)"/ do |executable, arguments|
+  @stdout = File.expand_path(File.join(@tmp_root, "executable.out"))
+  in_project_folder do
+    system "ruby -rubygems #{executable.inspect} #{arguments} > #{@stdout.inspect} 2> #{@stdout.inspect}"
+  end
+end
+
+When /^I run local executable "(.*)" with arguments "(.*)"/ do |executable, arguments|
+  if executable == "eldarscrolls"
+    require 'eldarscrolls'
+    require 'eldarscrolls/command'
+    in_project_folder do
+      stdout, stderr = capture_stdios do
+        Engineyard::Jenkins::CLI.start(arguments.split(/ /))
+      end
+      @stdout = File.expand_path(File.join(@tmp_root, "executable.out"))
+      File.open(@stdout, "w") {|f| f << stdout; f << stderr}
+    end
+  else
+    @stdout = File.expand_path(File.join(@tmp_root, "executable.out"))
+    executable = File.expand_path(File.join(File.dirname(__FILE__), "/../../bin", executable))
+    in_project_folder do
+      system "ruby -rubygems #{executable.inspect} #{arguments} > #{@stdout.inspect} 2> #{@stdout.inspect}"
+    end
+  end
+end
+
+When /^I invoke task "rake (.*)"/ do |task|
+  @stdout = File.expand_path(File.join(@tmp_root, "tests.out"))
+  in_project_folder do
+    system "bundle exec rake #{task} --trace > #{@stdout.inspect} 2> #{@stdout.inspect}"
+  end
+end
+
+Then /^folder "(.*)" (is|is not) created/ do |folder, is|
+  in_project_folder do
+    File.exists?(folder).should(is == 'is' ? be_true : be_false)
+  end
+end
+
+Then /^file "(.*)" (is|is not) created/ do |file, is|
+  in_project_folder do
+    File.exists?(file).should(is == 'is' ? be_true : be_false)
+  end
+end
+
+Then /^file with name matching "(.*)" is created/ do |pattern|
+  in_project_folder do
+    Dir[pattern].should_not be_empty
+  end
+end
+
+Then /^file "(.*)" contents (does|does not) match \/(.*)\// do |file, does, regex|
+  in_project_folder do
+    actual_output = File.read(file)
+    (does == 'does') ?
+      actual_output.should(match(/#{regex}/)) :
+      actual_output.should_not(match(/#{regex}/))
+  end
+end
+
+Then /^file "([^"]*)" contains "([^"]*)"$/ do |file, text|
+  in_project_folder do
+    actual_output = File.read(file)
+    actual_output.should contain(text)
+  end
+end
+
+
+Then /gem file "(.*)" and generated file "(.*)" should be the same/ do |gem_file, project_file|
+  File.exists?(gem_file).should be_true
+  File.exists?(project_file).should be_true
+  gem_file_contents = File.read(File.dirname(__FILE__) + "/../../#{gem_file}")
+  project_file_contents = File.read(File.join(@active_project_folder, project_file))
+  project_file_contents.should == gem_file_contents
+end
+
+Then /^(does|does not) invoke generator "(.*)"$/ do |does_invoke, generator|
+  actual_output = get_command_output
+  does_invoke == "does" ?
+    actual_output.should(match(/dependency\s+#{generator}/)) :
+    actual_output.should_not(match(/dependency\s+#{generator}/))
+end
+
+Then /help options "(.*)" and "(.*)" are displayed/ do |opt1, opt2|
+  actual_output = get_command_output
+  actual_output.should match(/#{opt1}/)
+  actual_output.should match(/#{opt2}/)
+end
+
+Then /^I should see "([^\"]*)"$/ do |text|
+  actual_output = get_command_output
+  actual_output.should contain(text)
+end
+
+Then /^I should not see "([^\"]*)"$/ do |text|
+  actual_output =
+  actual_output.should_not contain(text)
+end
+
+Then /^I should see$/ do |text|
+  actual_output = get_command_output
+  actual_output.should contain(text)
+end
+
+Then /^I should not see$/ do |text|
+  actual_output = get_command_output
+  actual_output.should_not contain(text)
+end
+
+Then /^I should see exactly$/ do |text|
+  actual_output = get_command_output
+  actual_output.should == text
+end
+
+Then /^I should see all (\d+) tests pass/ do |expected_test_count|
+  expected = %r{^#{expected_test_count} tests, \d+ assertions, 0 failures, 0 errors}
+  actual_output = get_command_output
+  actual_output.should match(expected)
+end
+
+Then /^I should see all (\d+) examples pass/ do |expected_test_count|
+  expected = %r{^#{expected_test_count} examples?, 0 failures}
+  actual_output = get_command_output
+  actual_output.should match(expected)
+end
+
+Then /^yaml file "(.*)" contains (\{.*\})/ do |file, yaml|
+  in_project_folder do
+    yaml = eval yaml
+    YAML.load(File.read(file)).should == yaml
+  end
+end
+
+Then /^Rakefile can display tasks successfully/ do
+  @stdout = File.expand_path(File.join(@tmp_root, "rakefile.out"))
+  in_project_folder do
+    system "rake -T > #{@stdout.inspect} 2> #{@stdout.inspect}"
+  end
+  actual_output = get_command_output
+  actual_output.should match(/^rake\s+\w+\s+#\s.*/)
+end
+
+Then /^task "rake (.*)" is executed successfully/ do |task|
+  @stdout.should_not be_nil
+  actual_output = get_command_output
+  actual_output.should_not match(/^Don't know how to build task '#{task}'/)
+  actual_output.should_not match(/Error/i)
+end
+
+Then /^gem spec key "(.*)" contains \/(.*)\// do |key, regex|
+  in_project_folder do
+    gem_file = Dir["pkg/*.gem"].first
+    gem_spec = Gem::Specification.from_yaml(`gem spec #{gem_file}`)
+    spec_value = gem_spec.send(key.to_sym)
+    spec_value.to_s.should match(/#{regex}/)
+  end
+end
+
+Then /^the file "([^\"]*)" is a valid gemspec$/ do |filename|
+  spec = eval(File.read(filename))
+  spec.validate
+end
+
+When /^I create a new node with the following options on "http:\/\/(.+?):(\d+)":$/ do |host, port, table|
+  options = table.raw.inject({}) do |options, (key, value)|
+    options[(key.to_sym rescue key) || key] = value
+    options
+  end
+
+  Jenkins::Api.setup_base_url(:host => host, :port => port.to_i)
+  Jenkins::Api.add_node(options)
+end