volt 0.8.27.beta6 → 0.8.27.beta7

data/lib/volt/server/rack/http_response_renderer.rb

@@ -0,0 +1,41 @@
+require 'json'
+require 'volt'
+
+module Volt
+  # Renders responses for HttpController actions
+  class HttpResponseRenderer
+    @renderers = {}
+
+    def self.renderers
+      @renderers
+    end
+
+    # Register renderers.
+    def self.register_renderer(name, content_type, proc)
+      @renderers[name.to_sym] = { proc: proc, content_type: content_type }
+    end
+
+    # Default renderers for json and plain text
+    register_renderer(:json, 'application/json', proc { |data| data.to_json })
+    register_renderer(:text, 'text/plain', proc { |data| data.to_s })
+
+    # Iterate through @renderes to find a matching renderer for the given
+    # content and call the given proc.
+    # Other params fromt he content are returned as additional headers
+    # Returns an empty string if no renderer could be found
+    def render(content)
+      content = content.symbolize_keys
+      self.class.renderers.keys.each do |renderer_name|
+        if content.key?(renderer_name)
+          renderer = self.class.renderers[renderer_name]
+          to_render = content.delete(renderer_name)
+          rendered = renderer[:proc].call(to_render)
+          return [rendered, content.merge(content_type: renderer[:content_type])]
+        end
+      end
+
+      # If we couldn't find a renderer - just render an empty string
+      ['', content_type: 'text/plain']
+    end
+  end
+end

data/lib/volt/spec/setup.rb

@@ -21,8 +21,10 @@ module Volt
       # Setup the spec collection accessors
       # RSpec.shared_context "volt collections", {} do
       RSpec.shared_examples_for 'volt collections', {} do
-        # Page conflicts with capybara's page method
-        # let(:page) { Model.new }
+        # Page conflicts with capybara's page method, so we call it the_page for now.
+        # TODO: we need a better solution for page
+
+        let(:the_page) { Model.new }
         let(:store) do
           @__store_accessed = true
           $page ||= Page.new

data/lib/volt/tasks/dispatcher.rb

@@ -18,8 +18,8 @@ module Volt
 
       start_time = Time.now.to_f
 
-      # Check that we are calling on a TaskHandler class and a method provide at
-      # TaskHandler or above in the ancestor chain.
+      # Check that we are calling on a Task class and a method provide at
+      # Task or above in the ancestor chain.
       if safe_method?(klass, method_name)
         promise.resolve(nil)
 
@@ -61,17 +61,17 @@ module Volt
 
     # Check if it is safe to use this method
     def safe_method?(klass, method_name)
-      # Make sure the class being called is a TaskHandler.
-      return false unless klass.ancestors.include?(TaskHandler)
+      # Make sure the class being called is a Task.
+      return false unless klass.ancestors.include?(Task)
 
       # Make sure the method is defined on the klass we're using and not up the hiearchy.
       #   ^ This check prevents methods like #send, #eval, #instance_eval, #class_eval, etc...
       klass.ancestors.each do |ancestor_klass|
         if ancestor_klass.instance_methods(false).include?(method_name)
           return true
-        elsif ancestor_klass == TaskHandler
-          # We made it to TaskHandler and didn't find the method, that means it
-          # was defined above TaskHandler, so we reject the call.
+        elsif ancestor_klass == Task
+          # We made it to Task and didn't find the method, that means it
+          # was defined above Task, so we reject the call.
           return false
         end
       end

data/lib/volt/tasks/task_handler.rb

@@ -1,5 +1,5 @@
 module Volt
-  class TaskHandler
+  class Task
     if RUBY_PLATFORM == 'opal'
       # On the front-end we setup a proxy class to the backend that returns
       # promises for all calls.

data/lib/volt/volt/users.rb

@@ -3,7 +3,7 @@ require 'thread'
 module Volt
   class << self
     # Get the user_id from the cookie
-    def user_id
+    def current_user_id
       # Check for a user_id from with_user
       if (user_id = Thread.current['with_user_id'])
         return user_id
@@ -52,17 +52,23 @@ module Volt
     end
 
     # True if the user is logged in and the user is loaded
-    def user?
-      !!user
+    def current_user?
+      !!current_user
     end
 
     # Return the current user.
-    def user
+    def current_user
       # Run first on the query, or return nil
       user_query.try(:first)
     end
 
-    def fetch_user
+    # Put in a deprecation placeholder
+    def user
+      Volt.logger.warning("deprication: Volt.user has been renamed to Volt.current_user (to be more clear about what it returns).  Volt.user will be deprecated in the future.")
+      current_user
+    end
+
+    def fetch_current_user
       u_query = user_query
       if u_query
         u_query.fetch_first
@@ -108,7 +114,7 @@ module Volt
     private
     # Returns a query for the current user_id or nil if there is no user_id
     def user_query
-      user_id = self.user_id
+      user_id = self.current_user_id
       if user_id
         $page.store._users.where(_id: user_id)
       else

data/spec/apps/kitchen_sink/app/main/config/routes.rb

@@ -1,16 +1,24 @@
 # See https://github.com/voltrb/volt#routes for more info on routes
 
-get '/bindings/{{ route_test }}', action: 'bindings'
-get '/bindings', action: 'bindings'
-get '/store', action: 'store'
-get '/cookie_test', action: 'cookie_test'
-get '/flash', action: 'flash'
-get '/yield', action: 'yield'
-get '/todos', controller: 'todos'
+client '/bindings/{{ route_test }}', action: 'bindings'
+client '/bindings', action: 'bindings'
+client '/store', action: 'store'
+client '/cookie_test', action: 'cookie_test'
+client '/flash', action: 'flash'
+client '/yield', action: 'yield'
+client '/todos', controller: 'todos'
 
 # Signup/login routes
-get '/signup', controller: 'user-templates', action: 'signup'
-get '/login', controller: 'user-templates', action: 'login'
+client '/signup', controller: 'user-templates', action: 'signup'
+client '/login', controller: 'user-templates', action: 'login'
+
+# HTTP endpoints
+get '/simple_http', controller: 'simple_http', action: 'index'
+get '/simple_http/store', controller: 'simple_http', action: 'show'
+post '/simple_http/upload', controller: 'simple_http', action: 'upload'
+
+# Route for file uploads
+client '/upload', controller: 'upload', action: 'index'
 
 # The main route, this should be last.  It will match any params not previously matched.
-get '/', {}
+client '/', {}

data/spec/apps/kitchen_sink/app/main/controllers/main_controller.rb

@@ -23,13 +23,13 @@ class MainController < Volt::ModelController
   end
 
   def cookie_test
-    self.model = page._new_cookie.buffer
+    self.model = page._new_cookie!.buffer
   end
 
   def add_cookie
     cookies.send(:"_#{_name.to_s}=", _value)
 
-    self.model = page._new_cookie.buffer
+    self.model = page._new_cookie!.buffer
   end
 
   def content_string

data/spec/apps/kitchen_sink/app/main/controllers/server/simple_http_controller.rb

@@ -0,0 +1,15 @@
+class SimpleHttpController < Volt::HttpController
+  def index
+    render text: 'this is just some text'
+  end
+
+  def show
+    render text: "You had me at #{store._simple_http_tests.first._name}"
+  end
+
+  def upload
+    uploaded = params[:file][:tempfile]
+    File.open('tmp/uploaded_file', 'wb') { |f| f.write(uploaded.read) }
+    render text: 'Thanks for uploading'
+  end
+end

data/spec/apps/kitchen_sink/app/main/controllers/upload_controller.rb

@@ -0,0 +1,22 @@
+class UploadController < Volt::ModelController
+  model :page
+
+  def index
+    # Nothing to setup here
+  end
+
+  def upload
+    `form_data = new FormData();
+     form_data.append("file", $('#file')[0].files[0]);
+     $.ajax({
+       url: '/simple_http/upload',
+       data: form_data,
+       processData: false,
+       contentType: false,
+       type: 'POST',
+       success: function(data){
+        $('#status').html("successfully uploaded");
+      }
+    });`
+  end
+end

data/spec/apps/kitchen_sink/app/main/views/main/yield.html

@@ -13,6 +13,6 @@
   <p>{{ yield }}</p>
 
 
-  {{ if Volt.user }}
-    Email: {{ Volt.user._email }}
+  {{ if Volt.current_user }}
+    Email: {{ Volt.current_user._email }}
   {{ end }}

data/spec/apps/kitchen_sink/app/main/views/upload/index.html

@@ -0,0 +1,15 @@
+<:Title>
+  File Upload
+
+<:Body>
+  <h1>File Upload Example</h1>
+
+  <form e-submit="upload">
+     <label>File</label>
+     <input class="form-control" id="file" type="file" />
+     <input type="submit" id="submit_file_upload">
+  </form>
+
+  <div id="status">
+  	waiting...
+  </div>

data/spec/controllers/http_controller_spec.rb

@@ -0,0 +1,130 @@
+if RUBY_PLATFORM != 'opal'
+  require 'volt/controllers/http_controller'
+  require 'volt/server/rack/http_request'
+  require 'volt/server/rack/http_resource'
+
+  describe Volt::HttpController do
+    class TestHttpController < Volt::HttpController
+      attr_reader :action_called
+
+      def just_call_an_action
+        @action_called = true
+      end
+
+      def ok_head_action
+        head :ok, location: 'http://example.com'
+      end
+
+      def created_head_action
+        head :created
+      end
+
+      def head_with_http_headers
+        head :ok, location: 'http://path.to/example'
+      end
+
+      def redirect_action
+        redirect_to 'http://path.to/example'
+      end
+
+      def render_plain_text
+        render text: 'just plain text'
+      end
+
+      def render_json
+        render json: { 'this' => 'is_json', 'another' => 'pair' }
+      end
+
+      def render_json_with_custom_headers
+        render json: { some: 'json' },
+               status: :created, location: '/test/location'
+      end
+
+      def access_body
+        render json: JSON.parse(request.body.read)
+      end
+    end
+
+    let(:app) { ->(env) { [404, env, 'app'] } }
+
+    let(:request) do
+      Volt::HttpRequest.new(
+        Rack::MockRequest.env_for('http://example.com/test.html',
+                                  'CONTENT_TYPE' => 'text/plain;charset=utf-8'))
+    end
+
+    let(:controller) { TestHttpController.new({}, request) }
+
+    it 'should merge the request params and the url params' do
+      request = Volt::HttpRequest.new(
+        Rack::MockRequest.env_for('http://example.com/test.html?this=is_a&test=param'))
+      controller = TestHttpController.new(
+        { another: 'params', 'and_a' => 'string' }, request)
+      expect(controller.params.size).to eq(4)
+      expect(controller.params[:and_a]).to eq('string')
+      expect(controller.params[:this]).to eq('is_a')
+    end
+
+    it 'should perform the correct action' do
+      expect(controller.action_called).not_to be(true)
+      controller.perform(:just_call_an_action)
+      expect(controller.action_called).to be(true)
+    end
+
+    it 'should redirect' do
+      expect(controller.action_called).not_to be(true)
+      response = controller.perform(:redirect_action)
+      expect(response.location).to eq('http://path.to/example')
+      expect(response.status).to eq(302)
+    end
+
+    it 'should respond with head' do
+      response = controller.perform(:ok_head_action)
+      expect(response.status).to eq(200)
+      expect(response.body).to eq([])
+
+      response = controller.perform(:created_head_action)
+      expect(response.status).to eq(201)
+
+      response = controller.perform(:head_with_http_headers)
+      expect(response.headers['Location']).to eq('http://path.to/example')
+      expect(response.location).to eq('http://path.to/example')
+    end
+
+    it 'should render plain text' do
+      response = controller.perform(:render_plain_text)
+      expect(response.status).to eq(200)
+      expect(response['Content-Type']).to eq('text/plain')
+      expect(response.body).to eq(['just plain text'])
+    end
+
+    it 'should render json' do
+      response = controller.perform(:render_json)
+      expect(response.status).to eq(200)
+      expect(response['Content-Type']).to eq('application/json')
+      expect(JSON.parse(response.body.first)).to eq('this' => 'is_json',
+                                                    'another' => 'pair')
+    end
+
+    it 'should set the correct status for rendered responses' do
+      response = controller.perform(:render_json_with_custom_headers)
+      expect(response.status).to eq(201)
+    end
+
+    it 'should include the custum headers' do
+      response = controller.perform(:render_json_with_custom_headers)
+      expect(response['Location']).to eq('/test/location')
+    end
+
+    it 'should have access to the body' do
+      http_app = Volt::HttpResource.new(app, nil)
+      allow(http_app).to receive(:routes_match?)
+        .and_return(controller: 'test_http',
+                    action: 'access_body')
+      request = Rack::MockRequest.new(http_app)
+      response = request.post('http://example.com/test.html', input:
+        { test: 'params' }.to_json)
+      expect(response.body).to eq({ test: 'params' }.to_json)
+    end
+  end
+end

data/spec/extra_core/string_transformation_test_cases.rb

@@ -17,3 +17,11 @@
     'street_address'        => 'street-address',
     'person_street_address' => 'person-street-address'
   }
+
+  UnderscoresToHeaders = {
+    'proxy_authenticate' => 'Proxy-Authenticate',
+    'set_cookie' => 'Set-Cookie',
+    'set-cookie' => 'Set-Cookie',
+    'via' => 'Via',
+    'WWW_Authenticate' => 'WWW-Authenticate'
+  }

data/spec/extra_core/string_transformations_spec.rb

@@ -45,3 +45,15 @@ describe '#camelize' do
     expect('HTMLTidyGenerator'.underscore).to eq('html_tidy_generator')
   end
 end
+
+describe '#headerize' do
+  it "headerizes" do
+    expect('test_case'.headerize).to eq('Test-Case')
+  end
+
+  UnderscoresToHeaders.each do |underscored, headerized|
+    it 'underscores' do
+      expect(underscored.headerize).to eq(headerized)
+    end
+  end  
+end

data/spec/integration/http_endpoints_spec.rb

@@ -0,0 +1,29 @@
+if ENV['BROWSER']
+  require 'spec_helper'
+
+  describe 'http endpoints', type: :feature, sauce: true do
+    it 'should show the page' do
+      visit '/simple_http'
+      expect(page).to have_content('this is just some text')
+    end
+
+    it 'should have access to the store' do
+      DataStore.new.drop_database
+      $page.store._simple_http_tests << { name: 'hello' }
+      visit '/simple_http/store'
+      expect(page).to have_content('You had me at hello')
+      DataStore.new.drop_database
+    end
+
+    it 'should upload and store a file' do
+      file = 'tmp/uploaded_file'
+      FileUtils.rm(file) if File.exist?(file)
+      visit '/upload'
+      attach_file('file', __FILE__)
+      find('#submit_file_upload').click
+      expect(page).to have_content('successfully uploaded')
+      expect(File.exist?(file)).to be(true)
+      FileUtils.rm(file) if File.exist?(file)
+    end
+  end
+end