Class: Camping::Generators

Inherits:

Object

• Object
• Camping::Generators

Defined in:

lib/camping/commands.rb

Class Method Summary

• .make_camp_file(app_name = "Tent") ⇒ Object
• .make_configkdl ⇒ Object

  write a config.kdl.

• .make_gemfile ⇒ Object

  write a Gemfile.

• .make_gitignore ⇒ Object

  makes a gitignore.

• .make_public_folder ⇒ Object
• .make_rakefile ⇒ Object

  writes a rakefile.

• .make_readme ⇒ Object

  write a README.md.

• .make_ruby_version ⇒ Object
• .make_test_folder ⇒ Object
• .make_test_helper ⇒ Object

  writes a test_helper.

• .read(file) ⇒ Object

  read a file.

• .write(file, content) ⇒ Object

  write a file.

Class Method Details

.make_camp_file(app_name = "Tent") ⇒ Object

# File 'lib/camping/commands.rb', line 154

def make_camp_file(app_name="Tent")
  write "camp.rb", <<-RUBY
require 'camping'

Camping.goes :#{app_name}

module #{app_name}
  module Models
  end

  module Controllers
    class Index
def get
  @title = "#{app_name}"
  render :index
end
    end
  end

  module Helpers
  end

  module Views

    def layout
html do
  head do
    title '#{app_name}'
    link :rel => 'stylesheet', :type => 'text/css',
    :href => '/styles.css', :media => 'screen'
  end
  body do
    h1 '#{app_name}'

    div.wrapper! do
      self << yield
    end
  end
end
    end

    def index
h2 "Let's go Camping"
    end

  end

end

RUBY
end

.make_configkdl ⇒ Object

write a config.kdl

# File 'lib/camping/commands.rb', line 317

def make_configkdl
  write 'config.kdl', <<-KDL
# config.kdl
hostname {
  default "localhost"
}
KDL
end

.make_gemfile ⇒ Object

write a Gemfile

# File 'lib/camping/commands.rb', line 327

def make_gemfile
  write 'Gemfile', <<-GEM
# frozen_string_literal: true
source 'https://rubygems.org'

gem 'camping'
gem 'puma'
gem 'rake'

group :production do
  gem 'rack-ssl-enforcer'
end

group :development do
end

group :test do
  gem 'minitest', '~> 5.0'
  gem 'minitest-reporters'
  gem 'rack-test'
  gem 'minitest-hooks'
end

GEM
end

.make_gitignore ⇒ Object

makes a gitignore.

# File 'lib/camping/commands.rb', line 207

def make_gitignore
  write '.gitignore', <<-GIT
.DS_Store
node_modules/
tmp/
db/camping.db
db/camping.sqlite3
db/camping.sqlite
GIT
end

.make_public_folder ⇒ Object

# File 'lib/camping/commands.rb', line 366

def make_public_folder
  Dir.mkdir("public") unless Dir.exist?("public")
end

.make_rakefile ⇒ Object

writes a rakefile

# File 'lib/camping/commands.rb', line 225

def make_rakefile
  write 'Rakefile', <<-TXT
# Rakefile
require 'rake'
require 'rake/clean'
require 'rake/testtask'
require 'tempfile'
require 'open3'

task :default => :test
task :test => 'test:all'

namespace 'test' do
  Rake::TestTask.new('all') do |t|
    t.libs << 'test'
    t.test_files = FileList['test/test_*.rb']
  end
end
TXT
end

.make_readme ⇒ Object

write a README.md

# File 'lib/camping/commands.rb', line 354

def make_readme
  write 'README.md', <<-READ
# Camping
Camping is really fun and I hope you enjoy it.

Start camping by running: `camping` in the root directory.

To start Camping in development mode run: `camping -e development

READ
end

.make_ruby_version ⇒ Object

# File 'lib/camping/commands.rb', line 218

def make_ruby_version
  write '.ruby-version', <<-RUBY
#{RUBY_VERSION}
RUBY
end

.make_test_folder ⇒ Object

# File 'lib/camping/commands.rb', line 370

def make_test_folder
  Dir.mkdir("test") unless Dir.exist?("test")
  write 'test/test_helper.rb', <<-RUBY
$:.unshift File.dirname(__FILE__) + '/../'
# shift to act like we're in the regular degular directory

begin
  require 'rubygems'
rescue LoadError
end

require 'camping'
require 'minitest/autorun'
require 'minitest'
require 'rack/test'
require "minitest/reporters"
Minitest::Reporters.use! [Minitest::Reporters::DefaultReporter.new(:color => true)]

class TestCase < MiniTest::Test
  include Rack::Test::Methods

  def self.inherited(mod)
    mod.app = Object.const_get(mod.to_s[/\w+/])
    super
  end

  class << self
    attr_accessor :app
  end

  def body() last_response.body end
  def app()  self.class.app     end

  def assert_reverse
    begin
yield
    rescue Exception
    else
assert false, "Block didn't fail"
    end
  end

  def assert_body(str)
    case str
    when Regexp
assert_match(str, last_response.body.strip)
    else
assert_equal(str.to_s, last_response.body.strip)
    end
  end

  def assert_status(code)
    assert_equal(code, last_response.status)
  end

  def test_silly; end

end

RUBY
end

.make_test_helper ⇒ Object

writes a test_helper

# File 'lib/camping/commands.rb', line 247

def make_test_helper
  write 'test/test_helper.r', <<-TXT
# Test Helper
$:.unshift File.dirname(__FILE__) + '/../'

begin
  require 'rubygems'
rescue LoadError
end

require 'minitest/autorun'
require 'rack/test'
require 'minitest/reporters'
require 'minitest/hooks'
Minitest::Reporters.use! [Minitest::Reporters::DefaultReporter.new(:color => true)]

# Default TestCase with some helpers.
# The same stuff we use for Camping itself.
class TestCase < MiniTest::Test
  include Rack::Test::Methods
  include Minitest::Hooks

  def self.inherited(mod)
    mod.app = Object.const_get(mod.to_s[/\w+/])
    super
  end

  class << self
    attr_accessor :app
  end

  def setup
    super
    Camping.make_camp
  end

  def body() last_response.body end
  def app()  self.class.app     end

  def response_body() last_response.to_a end

  def assert_reverse
    begin
yield
    rescue Exception
    else
assert false, "Block didn't fail"
    end
  end

  def assert_body(str, message="")
    case str
    when Regexp
assert_match(str, last_response.body.strip, message)
    else
assert_equal(str.to_s, last_response.body.strip, message)
    end
  end

  def assert_status(code, message="")
    assert_equal(code, last_response.status, message)
  end

  def test_silly; end
end

TXT
end

.read(file) ⇒ Object

read a file

# File 'lib/camping/commands.rb', line 150

def read(file)
  File.read(file)
end

.write(file, content) ⇒ Object

write a file

# File 'lib/camping/commands.rb', line 142

def write(file, content)
  raise "Cannot write to nil file." unless file
  folder = File.dirname(file)
  `mkdir -p #{folder}` unless File.exist?(folder)
  File.open(file, 'w') { |f| f.write content }
end