grails-mvc 0.1.8 → 0.1.91

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fa5a945e025edfb7bab7051aa90ea655b86bfe9d
-  data.tar.gz: 361fdcbb753ecf9d9690e073906c349dfe7491ee
+  metadata.gz: 5a8f23f63fdecec15c4b76fcb24a888e8bafdf6d
+  data.tar.gz: 5e71b2fcf017f9564896508e2f67b3876d9cd673
 SHA512:
-  metadata.gz: e194125dd902e3fabdf91dcc33368e3146207f31ec8576f61b2f52fbc694aa3161cfbce862de871ccd1ebf0a55a2e571ae1f1a49535a750d67e50809e503d430
-  data.tar.gz: 1f582d4deccabf3d16cdee70ebe82e3131384bdc5116320e693206c6d1e1e2f6daa6a43a1d3805e7ab101613f5a5bf7f82244a193a400de930886207424a6fd6
+  metadata.gz: c20b164478fdb30fbf637f7d056fcacb84e4246e961defb5a3bdc1065d75602ba84dbc0a7df8f2fcd1fceef42e3b02611431c343806e03f69380d03b630efc4a
+  data.tar.gz: 800fccd281b329b4d606adf3294953572c08aa30b279f93fb36b09fe749e8316c2cdba9f89f25a6a28f6f4900722d712325bfc2e5b5b5ad496432050bf31c69b

data/bin/grails

@@ -1,5 +1,5 @@
-#!/usr/bin/env ruby -U
+#!/usr/bin/env ruby
 
-require_relative '../lib/grails.rb'
+require 'grails'
 
 Grails::CLI.start(ARGV)

data/grails-mvc.gemspec

@@ -1,4 +1,4 @@
-
+# -*- encoding: utf-8 -*-
 lib = File.expand_path("../lib", __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require "version"
@@ -11,7 +11,7 @@ Gem::Specification.new do |spec|
 
   spec.summary       = %q{Grails is a lightweight MVC framework based on Rails!}
   spec.description   = %q{Build web applications easily with Grails!}
-  spec.homepage      = "https://github.com/victorwu3/grails/tree/master/bin"
+  spec.homepage      = "https://github.com/victorwu3/grails-mvc"
   spec.license       = "MIT"
 
   # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
@@ -23,18 +23,17 @@ Gem::Specification.new do |spec|
       "public gem pushes."
   end
 
-  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
-    f.match(%r{^(test|spec|features)/})
-  end
+  spec.files         = `git ls-files -z`.split("\x0")
   spec.bindir        = "bin"
-  spec.executables   = ["grails"]
+spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
   spec.add_dependency "thor", "~> 0.20"
   spec.add_dependency "httparty", "~> 0.13"
+  spec.add_dependency "rake", "~> 10.0"
   spec.add_dependency "sqlite3", "~> 1.3", ">= 1.3.5"
   spec.add_dependency "rack", "~> 1.6", ">= 1.6.4"
-  spec.add_dependency "rake", "~> 10.0"
+  spec.add_dependency "activesupport", "~> 4.2", ">= 4.2.5.2"
 
   spec.add_development_dependency "bundler", "~> 1.16"
   spec.add_development_dependency "rspec", "~> 3.0"

data/lib/commands.rb

@@ -23,7 +23,7 @@ module Grails
       raise "Model already exists" if File.exist?(path)
 
       File.open(path, "w") do |file|
-        file.write("class #{name.camelcase}" < GrailedORM::Base\n)
+        file.write("class #{name.camelcase} < GrailedORM::Base\n")
         file.write("   self.finalize!\n")
         file.write("end\n")
       end
@@ -34,7 +34,7 @@ module Grails
 
     desc "controller NAME", "creates a controller file and view folder"
     def controller(name)
-      controller_path = File.join(project_root, "app/controllers/#{file.pluralize.underscore}_controlller.rb"
+      controller_path = File.join(project_root, "app/controllers/#{file.pluralize.underscore}_controlller.rb")
       controller_name = "#{name.pluralize.camelcase}Controller"
       view_dir = File.join(project_root, "app/views/#{file.pluralize.underscore}")
       raise "Controller already exists" if File.exist?(controller_path)
@@ -72,9 +72,6 @@ module Grails
       app_dir = File.join(Dir.pwd, name)
       Raise "Directory of #{app_name} already exists" if Dir.exist?(app_dir)
       FileUtils.copy_enyry(TEMPLATE_PATH, app_dir)
-      Dir.mkdir(File.join(app_dir, "app/models"))
-      Dir.mkdir(File.join(app_dir, "app/controllers"))
-      Dir.mkdir(File.join(app_dir, "app/views"))
       Dir.mkdir(File.join(app_dir, "db/migrations"))
       File.new(File.join(app_dir, "config/routes.rb"))
       File.new(File.join(app_dir, "Gemfile"))

data/lib/controller_base.rb

@@ -5,7 +5,7 @@ require_relative './session'
 require_relative './flash'
 require 'active_support/inflector'
 
-Module GrailsController
+module GrailsController
   class Base
     attr_reader :req, :res, :params
 

data/lib/flash.rb

@@ -19,4 +19,5 @@ class Flash
 
   def []=(key, value)
     @flash[key.to_s] = value
+  end
 end

data/lib/grails.rb

@@ -0,0 +1,29 @@
+require 'fileutils'
+require 'pathname'
+require_relative 'version'
+
+
+module Grails
+  def self.project_root
+    current_dir = Pathname.new(Dir.pwd)
+    current_dir.ascend do |dir|
+      gemfile = File.exist?(File.join(dir, 'Gemfile'))
+      app_folder = Dir.exist?(File.join(dir, 'app'))
+      return dir if gemfile && app_folder
+    end
+    nil
+  end
+end
+
+GRAILS_ROOT = /^(.+)\/lib/.match(File.dirname(__FILE__))[1]
+TEMPLATE_PATH = File.join(GRAILS_ROOT, 'template')
+PROJECT_ROOT = Grails.project_root
+
+require_relative "#{PROJECT_ROOT}/config/database" if PROJECT_ROOT
+require_relative 'controller_base'
+require_relative 'flash'
+require_relative 'router'
+require_relative 'session'
+require_relative 'show_exceptions'
+require_relative 'static'
+require_relative 'commands'

data/lib/version.rb

@@ -1,3 +1,3 @@
 module Grails
-    VERSION = "0.1.8"
+    VERSION = "0.1.91"
 end

data/spec/controller_spec.rb

@@ -0,0 +1,84 @@
+require 'rack'
+require 'controller_base'
+
+describe ControllerBase do
+  before(:all) do
+    class UsersController < ControllerBase
+      def index
+      end
+    end
+  end
+  after(:all) { Object.send(:remove_const, 'UsersController') }
+
+  let(:req) { Rack::Request.new({'rack.input' => {}}) }
+  let(:res) { Rack::MockResponse.new('200',{},[]) }
+  let(:users_controller) { UsersController.new(req, res) }
+
+  describe '#render_content' do
+    before(:each) do
+      users_controller.render_content 'somebody', 'text/html'
+    end
+
+    it 'sets the response content type' do
+      expect(res['Content-Type']).to eq('text/html')
+    end
+
+    it 'sets the response body' do
+      expect(res.body).to eq('somebody')
+    end
+
+    describe '#already_built_response?' do
+      let(:users_controller2) { UsersController.new(req, res) }
+
+      it 'is false before rendering' do
+        expect(users_controller2.already_built_response?).to be_falsey
+      end
+
+      it 'is true after rendering content' do
+        users_controller2.render_content 'sombody', 'text/html'
+        expect(users_controller2.already_built_response?).to be_truthy
+      end
+
+      it 'raises an error when attempting to render twice' do
+        users_controller2.render_content 'sombody', 'text/html'
+        expect do
+          users_controller2.render_content 'sombody', 'text/html'
+        end.to raise_error
+      end
+    end
+  end
+
+  describe '#redirect' do
+    before(:each) do
+      users_controller.redirect_to('http://www.google.com')
+    end
+
+    it 'sets the header' do
+      expect(users_controller.res.header['location']).to eq('http://www.google.com')
+    end
+
+    it 'sets the status' do
+      expect(users_controller.res.status).to eq(302)
+    end
+
+    describe '#already_built_response?' do
+      let(:users_controller2) { UsersController.new(req, res) }
+
+      it 'is false before rendering' do
+        expect(users_controller2.already_built_response?).to be_falsey
+      end
+
+      it 'is true after rendering content' do
+        users_controller2.redirect_to('http://google.com')
+        expect(users_controller2.already_built_response?).to be_truthy
+      end
+
+      it 'raises an error when attempting to render twice' do
+        users_controller2.redirect_to('http://google.com')
+        expect do
+          users_controller2.redirect_to('http://google.com')
+        end.to raise_error
+      end
+    end
+  end
+end

data/spec/csrf_spec.rb

@@ -0,0 +1,92 @@
+require 'rack'
+require 'controller_base'
+require 'router'
+
+describe ControllerBase do
+  let(:req) { Rack::Request.new({'rack.input' => {}, 'REQUEST_METHOD' => 'GET'}) }
+  let(:res) { Rack::Response.new([], '200', {}) }
+  let(:controller_base) { ControllerBase.new(req, res) }
+
+  describe '#form_authenticity_token' do
+    it 'adds new cookie with \'authenticity_token\' name to response' do
+      controller_base.form_authenticity_token
+      cookie_str = res.headers['Set-Cookie']
+      cookie = Rack::Utils.parse_query(cookie_str)
+      expect(cookie['authenticity_token']).not_to be_nil
+    end
+
+    it 'returns the same token set in the cookie' do
+      token = controller_base.form_authenticity_token
+      cookie_str = res.headers['Set-Cookie']
+      cookie = Rack::Utils.parse_query(cookie_str)
+
+      expect(cookie['authenticity_token']).to eq(token)
+    end
+
+    it 'returns the same token when called multiple times in the same response' do
+      expect(controller_base.form_authenticity_token).to eq(controller_base.form_authenticity_token)
+    end
+  end
+
+  describe '#invoke_action' do
+    before(:all) do
+      class DummyController < ControllerBase
+        protect_from_forgery
+
+        def index
+        end
+      end
+
+      class CatsController < ControllerBase
+        def index
+        end
+      end
+    end
+
+    after(:all) do
+      Object.send(:remove_const, 'DummyController')
+      Object.send(:remove_const, 'CatsController')
+    end
+
+    it 'doesn\'t check authenticity token for a GET request' do
+      dummy_controller = DummyController.new(req, res)
+
+      expect(dummy_controller).not_to receive(:check_authenticity_token)
+      dummy_controller.invoke_action(:index)
+    end
+
+    it 'doesn\'t check authenticity token unless ::protect_from_forgery is called' do
+      nonsecure_controller = CatsController.new(req, res)
+
+      expect(nonsecure_controller).not_to receive(:check_authenticity_token)
+      nonsecure_controller.invoke_action(:index)
+    end
+
+    context 'a non-GET request' do
+      let(:dummy_controller) { DummyController.new(req, res) }
+
+      before(:each) do
+        allow(req).to receive(:request_method).and_return('POST')
+      end
+
+      it 'calls #check_authenticity_token' do
+        expect(dummy_controller).to receive(:check_authenticity_token)
+        dummy_controller.invoke_action(:index)
+      end
+
+
+      it 'raises an error with an invalid token for any non-GET request' do
+        expect { dummy_controller.invoke_action(:index) }.to raise_error('Invalid authenticity token')
+      end
+
+      it 'doesn\'t raise an error when a valid authenticity token is given' do
+
+        # Simulate auth token being passed in both in params from form and cookies
+        dummy_controller.params['authenticity_token'] = 'mocktoken'
+        req.env['HTTP_COOKIE'] = 'authenticity_token=mocktoken'
+
+        expect { dummy_controller.invoke_action(:index) }.not_to raise_error
+      end
+    end
+  end
+end

data/spec/exceptions_spec.rb

@@ -0,0 +1,51 @@
+# require 'rack/show_exceptions'
+require 'rack/lint'
+require 'rack/mock'
+require 'show_exceptions'
+
+describe ShowExceptions do
+  let(:show_exceptions) { ShowExceptions.new(app) }
+  let(:good_dummy_app) { Proc.new {} }
+  let(:bad_dummy_app) { Proc.new { raise RuntimeError }}
+
+  describe '#initialize' do
+    it 'initializes with an app' do
+      mock_exception = ShowExceptions.new(good_dummy_app)
+      expect(mock_exception.app).to be(good_dummy_app)
+    end
+  end
+
+  describe '#call' do
+
+    let(:env) { {} }
+
+    it 'calls #call on the app' do
+      mock_exception = ShowExceptions.new(good_dummy_app)
+      expect(good_dummy_app).to receive(:call).with(env)
+      mock_exception.call(env)
+    end
+
+    context 'when an app throws an error' do
+      let(:mock_exception) { ShowExceptions.new(bad_dummy_app) }
+
+      it 'catches exceptions' do
+        expect { mock_exception.call(env) }.not_to raise_error
+      end
+
+      it 'sets the status code to 500' do
+        response = mock_exception.call(env)
+        expect(response[0]).to eq '500'
+      end
+
+      it 'sets the content type to text/html' do
+        response = mock_exception.call(env)
+        expect(response[1]).to eq({'Content-type' => 'text/html'})
+      end
+
+      it 'the body of the response includes the error type' do
+        response = mock_exception.call(env)
+        expect(response[2]).to include 'RuntimeError'
+      end
+    end
+  end
+end

data/spec/flash_spec.rb

@@ -0,0 +1,93 @@
+require 'rack'
+require 'flash'
+require 'controller_base'
+
+describe Flash do
+  let(:req) { Rack::Request.new({'rack.input' => {}}) }
+  let(:res) { Rack::Response.new([], '200', {}) }
+  let(:flash) { Flash.new(req) }
+
+  describe '#[]=' do
+    it 'sets data in flash' do
+      flash['golden gate park'] = 'bison'
+      expect(flash['golden gate park']).to eq('bison')
+    end
+  end
+
+  describe '#store_flash' do
+    before(:each) do
+      flash['first_key'] = 'first_val'
+      flash.store_flash(res)
+    end
+
+    it 'adds new cookie with \'_rails_lite_app_flash\' name to response' do
+      cookie_str = res.headers['Set-Cookie']
+      cookie = Rack::Utils.parse_query(cookie_str)
+      expect(cookie['_rails_lite_app_flash']).not_to be_nil
+    end
+
+    it 'stores the cookie in JSON format' do
+      cookie_str = res.headers['Set-Cookie']
+      cookie = Rack::Utils.parse_query(cookie_str)
+      cookie_val = cookie['_rails_lite_app_flash']
+      cookie_hash = JSON.parse(cookie_val)
+
+      expect(cookie_hash).to be_instance_of(Hash)
+      expect(cookie_hash['first_key']).to eq('first_val')
+    end
+
+    it 'does not persist data more than 1 request' do
+      second_req = Rack::Request.new({'rack.input' => {}})
+      second_res = Rack::Response.new([], '200', {})
+
+      cookie_str = res.headers['Set-Cookie']
+      cookie = Rack::Utils.parse_query(cookie_str)
+
+      second_req.cookies.merge!(cookie)
+
+      second_flash = Flash.new(second_req)
+      second_flash.store_flash(second_res)
+
+      second_cookie_str = second_res.headers['Set-Cookie']
+      second_cookie = Rack::Utils.parse_query(second_cookie_str)
+      second_cookie_val = second_cookie['_rails_lite_app_flash']
+      second_cookie_hash = JSON.parse(second_cookie_val)
+
+      expect(second_cookie_hash).not_to have_key('first_key')
+    end
+  end
+
+  describe '#[]' do
+    it 'reads data from flash cookie' do
+      cookie = { '_rails_lite_app_flash' => { 'best_pizza' => 'Arizmendi' }.to_json }
+      req.cookies.merge!(cookie)
+      updated_flash = Flash.new(req)
+      expect(updated_flash['best_pizza']).to eq('Arizmendi')
+    end
+
+    it 'can be accessed using either strings or symbols' do
+      flash = Flash.new(req)
+      flash['notice'] = 'test'
+      expect(flash[:notice]).to eq('test')
+    end
+  end
+
+  describe '#now' do
+    before(:each) do
+      flash.now['abc'] = 'xyz'
+    end
+
+    it 'reads data from flash.now' do
+      expect(flash['abc']).to eq('xyz')
+    end
+
+    it 'does not persist flash.now data' do
+      flash.store_flash(res)
+      cookie_str = res.headers['Set-Cookie']
+      cookie = Rack::Utils.parse_query(cookie_str)
+      cookie_val = cookie['_rails_lite_app_flash']
+      cookie_hash = JSON.parse(cookie_val)
+      expect(cookie_hash['abc']).to be_nil
+    end
+  end
+end

data/spec/integration_spec.rb

@@ -0,0 +1,64 @@
+require 'rack'
+require 'controller_base'
+require 'router'
+
+describe 'the symphony of things' do
+  let(:req) { Rack::Request.new({'rack.input' => ''}) }
+  let(:res) { Rack::MockResponse.new('200', [], {}) }
+
+  before(:all) do
+    class Ctrlr < ControllerBase
+      def route_render
+        render_content('testing', 'text/html')
+      end
+
+      def route_does_params
+        render_content("got ##{params['id']}", 'text/text')
+      end
+
+      def update_session
+        session['token'] = 'testing'
+        render_content('hi', 'text/html')
+      end
+    end
+  end
+  after(:all) { Object.send(:remove_const, 'Ctrlr') }
+
+  describe 'routes and params' do
+    it 'route instantiates controller and calls invoke action' do
+      route = Route.new(Regexp.new('^/statuses/(?<id>\\d+)$'), :get, Ctrlr, :route_render)
+      allow(req).to receive(:path) { '/statuses/1' }
+      allow(req).to receive(:request_method) { 'GET' }
+      route.run(req, res)
+      expect(res.body).to eq('testing')
+    end
+
+    it 'route adds to params' do
+      route = Route.new(Regexp.new('^/statuses/(?<id>\\d+)$'), :get, Ctrlr, :route_does_params)
+      allow(req).to receive(:path) { '/statuses/1' }
+      allow(req).to receive(:request_method) { 'GET' }
+      route.run(req, res)
+      expect(res.body).to eq('got #1')
+    end
+  end
+
+  describe 'controller sessions' do
+    let(:ctrlr) { Ctrlr.new(req, res) }
+
+    it 'exposes a session via the session method' do
+      expect(ctrlr.session).to be_instance_of(Session)
+    end
+
+    it 'saves the session after rendering content' do
+      ctrlr.update_session
+      # Currently broken when flash is used. Need to store flash in the cookie
+      # or change this spec.
+      expect(res.headers['Set-Cookie']).to_not be_empty
+      cookie_str = res.headers['Set-Cookie']
+      cookie_val = Rack::Utils.parse_query(cookie_str)
+      cookie_str = cookie_val['_rails_lite_app']
+      cookie_hash = JSON.parse(cookie_str)
+      expect(cookie_hash['token']).to eq('testing')
+    end
+  end
+end

data/spec/router_spec.rb

@@ -0,0 +1,157 @@
+require 'rack'
+require 'router'
+require 'controller_base'
+
+describe Route do
+  let(:req) { Rack::Request.new({'rack.input' => {}}) }
+  let(:res) { Rack::MockResponse.new('200', {}, []) }
+
+  before(:each) do
+    allow(req).to receive(:request_method).and_return('GET')
+  end
+
+  describe '#matches?' do
+    it 'matches simple regular expression' do
+      index_route = Route.new(Regexp.new('^/users$'), :get, 'x', :x)
+      allow(req).to receive(:path) { '/users' }
+      allow(req).to receive(:request_method) { 'GET' }
+      expect(index_route.matches?(req)).to be_truthy
+    end
+
+    it 'matches regular expression with capture' do
+      index_route = Route.new(Regexp.new('^/users/(?<id>\\d+)$'), :get, 'x', :x)
+      allow(req).to receive(:path) { '/users/1' }
+      allow(req).to receive(:request_method) { 'GET' }
+      expect(index_route.matches?(req)).to be_truthy
+    end
+
+    it 'correctly doesn\'t match regular expression with capture' do
+      index_route = Route.new(Regexp.new('^/users/(?<id>\\d+)$'), :get, 'UsersController', :index)
+      allow(req).to receive(:path) { '/statuses/1' }
+      allow(req).to receive(:request_method) { 'GET' }
+      expect(index_route.matches?(req)).to be_falsey
+    end
+  end
+
+  describe '#run' do
+    before(:all) { class DummyController; end }
+    after(:all) { Object.send(:remove_const, 'DummyController') }
+
+    it 'instantiates controller and invokes action' do
+      # reader beware. hairy adventures ahead.
+      # this is really checking way too much implementation,
+      # but tests the approach recommended in the project
+      allow(req).to receive(:path) { '/users' }
+
+      dummy_controller_class = DummyController
+      dummy_controller_instance = DummyController.new
+      allow(dummy_controller_instance).to receive(:invoke_action)
+      allow(dummy_controller_class).to receive(:new).with(req, res, {}) do
+        dummy_controller_instance
+      end
+      expect(dummy_controller_instance).to receive(:invoke_action)
+      index_route = Route.new(Regexp.new('^/users$'), :get, dummy_controller_class, :index)
+      index_route.run(req, res)
+    end
+  end
+end
+
+describe Router do
+  let(:req) { Rack::Request.new({'rack-input' => {}}) }
+  let(:res) { Rack::MockResponse.new('200', {}, []) }
+
+  describe '#add_route' do
+    it 'adds a route' do
+      subject.add_route(1, 2, 3, 4)
+      expect(subject.routes.count).to eq(1)
+      subject.add_route(1, 2, 3, 4)
+      subject.add_route(1, 2, 3, 4)
+      expect(subject.routes.count).to eq(3)
+    end
+  end
+
+  describe '#match' do
+    it 'matches a correct route' do
+      subject.add_route(Regexp.new('^/users$'), :get, :x, :x)
+      allow(req).to receive(:path) { '/users' }
+      allow(req).to receive(:request_method) { 'GET' }
+      matched = subject.match(req)
+      expect(matched).not_to be_nil
+    end
+
+    it 'doesn\'t match an incorrect route' do
+      subject.add_route(Regexp.new('^/users$'), :get, :x, :x)
+      allow(req).to receive(:path) { '/incorrect_path' }
+      allow(req).to receive(:request_method) { 'GET' }
+      matched = subject.match(req)
+      expect(matched).to be_nil
+    end
+  end
+
+  describe '#run' do
+    it 'sets status to 404 if no route is found' do
+      subject.add_route(Regexp.new('^/users$'), :get, :x, :x)
+      allow(req).to receive(:path).and_return('/incorrect_path')
+      allow(req).to receive(:request_method).and_return('GET')
+      subject.run(req, res)
+      expect(res.status).to eq(404)
+    end
+  end
+
+  describe 'http method (get, put, post, delete)' do
+    it 'adds methods get, put, post and delete' do
+      router = Router.new
+      expect((router.methods - Class.new.methods)).to include(:get)
+      expect((router.methods - Class.new.methods)).to include(:put)
+      expect((router.methods - Class.new.methods)).to include(:post)
+      expect((router.methods - Class.new.methods)).to include(:delete)
+    end
+
+    it 'adds a route when an http method method is called' do
+      router = Router.new
+      router.get Regexp.new('^/users$'), ControllerBase, :index
+      expect(router.routes.count).to eq(1)
+    end
+  end
+
+  describe '#draw' do
+    it 'calls http method methods with the route information to add the route' do
+      index_route = double('route')
+      post_route = double('route')
+
+      routes = Proc.new do
+        get index_route
+        post post_route
+      end
+
+      router = Router.new
+
+      expect(router).to receive(:get).with(index_route)
+      expect(router).to receive(:post).with(post_route)
+
+      router.draw(&routes)
+    end
+  end
+end
+
+describe 'ControllerBase#initialize' do
+  before(:all) do
+    class CatsController < ControllerBase
+      def index
+        @cats = ['Gizmo']
+      end
+    end
+  end
+
+  after(:all) { Object.send(:remove_const, 'CatsController') }
+
+  let(:req) { Rack::Request.new({'rack.input' => {}}) }
+  let(:res) { Rack::MockResponse.new('200', {}, []) }
+  let(:cats_controller) { CatsController.new(req, res, { 'key' => 'val' } ) }
+
+  context '#initialize' do
+    it 'includes route params in the params object' do
+      expect(cats_controller.params['key']).to eq('val')
+    end
+  end
+end

data/spec/session_spec.rb

@@ -0,0 +1,110 @@
+require 'rack'
+require 'session'
+require 'controller_base'
+
+describe Session do
+  let(:req) { Rack::Request.new({ 'rack.input' => {} }) }
+  let(:res) { Rack::Response.new([], '200', {}) }
+  let(:cook) { {'_rails_lite_app' => { 'xyz' => 'abc' }.to_json} }
+
+  it 'deserializes json cookie if one exists' do
+    req.cookies.merge!(cook)
+    session = Session.new(req)
+    expect(session['xyz']).to eq('abc')
+  end
+
+  describe '#store_session' do
+    context 'without cookies in request' do
+      before(:each) do
+        session = Session.new(req)
+        session['first_key'] = 'first_val'
+        session.store_session(res)
+      end
+
+      it 'adds new cookie with \'_rails_lite_app\' name to response' do
+        cookie_str = res.headers['Set-Cookie']
+        cookie = Rack::Utils.parse_query(cookie_str)
+        expect(cookie['_rails_lite_app']).not_to be_nil
+      end
+
+      it 'stores the cookie in json format' do
+        cookie_str = res.headers['Set-Cookie']
+        cookie = Rack::Utils.parse_query(cookie_str)
+        cookie_val = cookie['_rails_lite_app']
+        cookie_hash = JSON.parse(cookie_val)
+        expect(cookie_hash).to be_instance_of(Hash)
+      end
+    end
+
+    context 'with cookies in request' do
+      before(:each) do
+        cook = {'_rails_lite_app' => { 'pho' => 'soup' }.to_json }
+        req.cookies.merge!(cook)
+      end
+
+      it 'reads the pre-existing cookie data into hash' do
+        session = Session.new(req)
+        expect(session['pho']).to eq('soup')
+      end
+
+      it 'saves new and old data to the cookie' do
+        session = Session.new(req)
+        session['machine'] = 'mocha'
+        session.store_session(res)
+        cookie_str = res['Set-Cookie']
+        cookie = Rack::Utils.parse_query(cookie_str)
+        cookie_val = cookie['_rails_lite_app']
+        cookie_hash = JSON.parse(cookie_val)
+        expect(cookie_hash['pho']).to eq('soup')
+        expect(cookie_hash['machine']).to eq('mocha')
+      end
+    end
+  end
+end
+
+describe ControllerBase do
+  before(:all) do
+    class CatsController < ControllerBase
+    end
+  end
+  after(:all) { Object.send(:remove_const, 'CatsController') }
+
+  let(:req) { Rack::Request.new({'rack.input' => {}}) }
+  let(:res) { Rack::Response.new([], '200', {}) }
+  let(:cats_controller) { CatsController.new(req, res) }
+
+  describe '#session' do
+    it 'returns a session instance' do
+      expect(cats_controller.session).to be_a(Session)
+    end
+
+    it 'returns the same instance on successive invocations' do
+      first_result = cats_controller.session
+      expect(cats_controller.session).to be(first_result)
+    end
+  end
+
+  shared_examples_for 'storing session data' do
+    it 'should store the session data' do
+      cats_controller.session['test_key'] = 'test_value'
+      cats_controller.send(method, *args)
+      cookie_str = res['Set-Cookie']
+      cookie = Rack::Utils.parse_query(cookie_str)
+      cookie_val = cookie['_rails_lite_app']
+      cookie_hash = JSON.parse(cookie_val)
+      expect(cookie_hash['test_key']).to eq('test_value')
+    end
+  end
+
+  describe '#render_content' do
+    let(:method) { :render_content }
+    let(:args) { ['test', 'text/plain'] }
+    include_examples 'storing session data'
+  end
+
+  describe '#redirect_to' do
+    let(:method) { :redirect_to }
+    let(:args) { ['http://appacademy.io'] }
+    include_examples 'storing session data'
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,13 @@
+require "bundler/setup"
+
+RSpec.configure do |config|
+  # Enable flags like --only-failures and --next-failure
+  config.example_status_persistence_file_path = ".rspec_status"
+
+  # Disable RSpec exposing methods globally on `Module` and `main`
+  config.disable_monkey_patching!
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end

data/spec/static_spec.rb

@@ -0,0 +1,24 @@
+
+require 'static'
+require 'rack'
+
+class DummyApp
+  def call(env)
+    [200, {'Content-Type' => 'text/plain'}, ['Hello World']]
+  end
+end
+
+describe Static do
+  let(:static) { Static.new(DummyApp.new) }
+  let(:request) { Rack::MockRequest.new(static) }
+
+  it 'serves files' do
+    res = request.get('/public/hello.txt')
+    expect(res.body).to match(/Hello there friend/)
+  end
+
+  it '404s if url root is known but it can\'t find the file' do
+    res = request.get('/public/nicholas.jpg')
+    expect(res.status).to be(404)
+  end
+end

data/spec/template_spec.rb

@@ -0,0 +1,55 @@
+require 'rack'
+require 'controller_base'
+
+describe ControllerBase do
+  before(:all) do
+    class CatsController < ControllerBase
+      def index
+        @cats = ['GIZMO']
+      end
+    end
+  end
+  after(:all) { Object.send(:remove_const, 'CatsController') }
+
+  let(:req) { Rack::Request.new({'rack.input' => {}}) }
+  let(:res) { Rack::MockResponse.new('200', {}, []) }
+  let(:cats_controller) { CatsController.new(req, res) }
+
+  describe '#render' do
+    before(:each) do
+      cats_controller.index
+      cats_controller.render(:index)
+    end
+
+    it 'renders the html of the index view' do
+      expect(cats_controller.res.body).to include('ALL THE CATS')
+      expect(cats_controller.res.body).to include('<h1>')
+      expect(cats_controller.res['Content-Type']).to eq('text/html')
+    end
+
+    it 'shows the proper instance variables in the index view' do
+      expect(cats_controller.res.body).to include('GIZMO')
+      expect(cats_controller.res['Content-Type']).to eq('text/html')
+    end
+
+    describe '#already_built_response?' do
+      let(:cats_controller2) { CatsController.new(req, res) }
+
+      it 'is false before rendering' do
+        expect(cats_controller2.already_built_response?).to be_falsey
+      end
+
+      it 'is true after rendering content' do
+        cats_controller2.render(:index)
+        expect(cats_controller2.already_built_response?).to be_truthy
+      end
+
+      it 'raises an error when attempting to render twice' do
+        cats_controller2.render(:index)
+        expect do
+          cats_controller2.render(:index)
+        end.to raise_error
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: grails-mvc
 version: !ruby/object:Gem::Version
-  version: 0.1.8
+  version: 0.1.91
 platform: ruby
 authors:
 - Victor Wu
@@ -38,6 +38,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.13'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
 - !ruby/object:Gem::Dependency
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement
@@ -79,19 +93,25 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 1.6.4
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '4.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.2.5.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '4.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.2.5.2
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -157,8 +177,7 @@ dependencies:
 description: Build web applications easily with Grails!
 email:
 - victor.wu.1@vanderbilt.edu
-executables:
-- grails
+executables: []
 extensions: []
 extra_rdoc_files: []
 files:
@@ -175,6 +194,9 @@ files:
 - bin/grails
 - bin/server.rb
 - bin/setup
+- boilerplate/db/database.sql
+- boilerplate/db/schema.sql
+- boilerplate/db/seed.sql
 - grailedorm/.rspec
 - grailedorm/Gemfile
 - grailedorm/Gemfile.lock
@@ -192,12 +214,23 @@ files:
 - lib/commands.rb
 - lib/controller_base.rb
 - lib/flash.rb
+- lib/grails.rb
 - lib/router.rb
 - lib/session.rb
 - lib/show_exceptions.rb
 - lib/static.rb
 - lib/version.rb
-homepage: https://github.com/victorwu3/grails/tree/master/bin
+- spec/controller_spec.rb
+- spec/csrf_spec.rb
+- spec/exceptions_spec.rb
+- spec/flash_spec.rb
+- spec/integration_spec.rb
+- spec/router_spec.rb
+- spec/session_spec.rb
+- spec/spec_helper.rb
+- spec/static_spec.rb
+- spec/template_spec.rb
+homepage: https://github.com/victorwu3/grails-mvc
 licenses:
 - MIT
 metadata: