rackstep 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0bcdfa5d5dd2b3e0861787e21c39e6483ff74dac
-  data.tar.gz: 0fb53c222f6489e3cce137c87e5379178ca2840a
+  metadata.gz: c61f80d81dce85a8edaf0aed8f3c9a6191a335a6
+  data.tar.gz: 45afba957a83cb16b42daeb03edfd1e35507a642
 SHA512:
-  metadata.gz: 6c8b46758537e23e28251a61f65f6c5e20f37f1191e2e7b8f0305d630af3e5d8fc1544646e820453818d2fc477020c38af258071413a9247c01ebfa7234f7045
-  data.tar.gz: 569bd479abffb8c79b51de1a5f4c758ab7c6949d54f4b8fc3bb8e6b5e8ee05c8292482e5204a99a0ca4552f561d8b60b1bf5640bdbef368b888fbf010c3b34ae
+  metadata.gz: 55ddab5bb82ae17d6821fb471e015f57f7cfa35991efdbef1d74932199918b33a6f3bd9f46947905248483864f328306be47d9645ee887782ddd6f65ab7f9ca4
+  data.tar.gz: 3c939a6c913167405185302027236d64ee889a245785a394d3ca16afe126231cdad192c7dc9a22aae350cbd3824a39403bf9a0863401a05b1bc88bbcd841ae12

data/lib/controller.rb

@@ -7,17 +7,20 @@ module RackStep
 
     # The request will be injected here.
     attr_accessor :request
-    # Represents the response information that will be delivered to the user
-    # (a Hash with contentType, content and httpStatus).
-    # By default httpStatus is 200 and contentType is application/json.
+
+    # The Rack::Response object that will be delivered to the user.
     attr_accessor :response
 
+    # The 'global' app settings will be injected here. This may contain
+    # references to things that should be initialize only once during the app
+    # start (eg: database connection).
+    attr_accessor :settings
+
     def initialize
-      @response = Hash.new
-      @response[:contentType] = 'application/json'
-      @response[:httpStatus]  = 200
-      @response[:content] = ''
-      @pagesDirectory = 'app/public/pages'
+      @response = RackStep::Response.new
+      @response.body = ''
+      @response.content_type = 'application/json'
+      @response.status = 200
     end
 
     # RackStep will always execute this method before delegating the request
@@ -27,16 +30,74 @@ module RackStep
     def before
     end
 
-    # This is not the best way to serve static content. In production, consider
-    # using Nginx or Apache. Using ruby/rack to serve static content is a waste
-    # of resources and should be only used for low traffic web pages. This
-    # method is provided so that in this circumstances you may use it to keep a
-    # simpler architecture.
-    def render_page(pageName)
-      response[:contentType] = 'text/html'
-      File.read("#{@pagesDirectory}/#{pageName}.html")
+    # RackStep will always execute this method after processing the request
+    # of to the specified method. The user may overwrite this method.
+    # This can be used to check for logging or any piece of code
+    # that must be executed after every request for this controller.
+    def after
+    end
+
+  end
+
+
+  # This controller will handle error the error "page not found". The user may
+  # overwrite this by creating new router to 'notfound'.
+  class ErrorController < RackStep::Controller
+
+    def not_found
+      @response.body = '404 - Page not found'
+      @response.content_type = 'text/plain'
+      @response.status  = 404
+    end
+
+  end
+
+end
+
+# A module for controllers to add static html pages rendering.
+# This is not the best way to serve static content. In production, consider
+# using Nginx or Apache. Using ruby/rack to serve static content is a waste
+# of resources and should be only used for low traffic web pages. This
+# method is provided so that in this circumstances you may use it to keep a
+# simpler architecture.
+module RackStep::Controller::HtmlRendering
+  def render_page(page_name, pages_directory = 'app/public/pages')
+    File.read("#{pages_directory}/#{page_name}.html")
+  end
+end
+
+# A module for controllers to add ERB template rendering. RackStep is not meant
+# to be used for template rendering. We recommend you to use a SPA (Single Page
+# Application) approach. But if you want to, you may include this module into
+# your controller and render ERB templates, following the old ruby web way.
+# TODO: Add layout support.
+module RackStep::Controller::ErbRendering
+
+  require 'erb'
+
+  def render_erb(template_name, erb_template_directory = 'app/public/pages')
+    template_path = "#{erb_template_directory}/#{template_name}.erb"
+    erb = ERB.new(File.open(template_path).read)
+    return erb.result(binding)
+  end
+
+end
+
+# A module for controllers to add basic http authentication helper method.
+module RackStep::Controller::BasicHttpAuthentication
+
+  def basic_access_authentication_credentials
+    credentials = nil
+    # Trying to get the basic http authentication credentials from the request.
+    auth = Rack::Auth::Basic::Request.new(request.env)
+    if auth.provided? and auth.basic? and auth.credentials
+      credentials = auth.credentials
+    else
+      # No credentials found. Will return empty to avoid returning nil.
+      credentials = ['', '']
     end
 
+    return credentials
   end
 
 end

data/lib/rackstep.rb

@@ -8,44 +8,59 @@ module RackStep
     # We will store the request and create a router in this class initializer.
     attr_reader :request, :router
 
+    # Settings is a hash that will be injected into the controller. This hash
+    # may contain "global" settings, like a connection to database, and other
+    # things that should be initiaized only once while the app is starting.
+    attr_accessor :settings
+
     # Static method called from config.ru ("run App").
     def self.call(env)
       new(env).process_request
     end
 
     def initialize(env)
+      # TODO: Is it ok to leave request as an attribute?
       @request = Rack::Request.new(env)
       @router = RackStep::Router.new
+      @settings = Hash.new
+
+      # Adding default routes to handle page not found (404).
+      for_all_verbs_add_route('notfound', 'RackStep::ErrorController', 'not_found')
     end
 
     def process_request
-      # Trying to find what controller should process this request.
-      # This will return a hash with the name of the controller, the
-      # method (action), etc.
-      route = router.find_route_for(request)
-      # If no valid route is found, will break the request and return http 404
-      # (page not found).
-      if (route == nil)
-        return page_not_found_response
-      end
-      # Initialize the correspondent controller
+      verb = request.request_method
+      path = request.path
+
+      # In RackStep, each request is processed by a method of a controller. The
+      # router is responsable to find, based on the given path and http verb,
+      # the apropriate controller and method to handle the request.
+      route = router.find_route_for(path, verb)
+      # Initialize the correspondent controller.
       controller = Object.const_get(route.controller).new
-      # Inject the request into the Controller
+      # Inject the request into the controller.
       controller.request = request
-      # Execute the before method of this controller
+      # Inject the settings into the controller.
+      controller.settings = settings
+      # Execute the before method of this controller.
       controller.send(:before)
-      # Execute the apropriate method/action
+      # Execute the apropriate method/action.
       controller.send(route.method)
+      # Execute the after method of this controller.
+      controller.send(:after)
+      # Get from the controller what is the response for this request.
       response = controller.response
-      # Generate a rack response that will be returned to the user
-      Rack::Response.new( response[:content],
-                          response[:httpStatus],
-                          {'Content-Type' => response[:contentType]} )
+
+      return response
     end
 
-    # Will use this as response when no route is found.
-    def page_not_found_response
-      Rack::Response.new("404 - Page not found", 404)
+    # Adds new routes to the application, one for each possible http verb (GET,
+    # POST, DELETE and PUT).
+    def for_all_verbs_add_route(path, controller, method)
+      @router.add_route('GET', path, controller, method)
+      @router.add_route('POST', path, controller, method)
+      @router.add_route('DELETE', path, controller, method)
+      @router.add_route('PUT', path, controller, method)
     end
 
     # Adds a new route to the application.
@@ -55,4 +70,30 @@ module RackStep
 
   end
 
+  # Let's extend the Rack Response class to add a few methods to make the life
+  # of the developer a little easier.
+  class Response < Rack::Response
+
+    # The original body= method of Rack::Response expects an array. In RackStep
+    # the user may set it as a String and we will convert it to array if
+    # necessary.
+    def body=(value)
+      if value.is_a?(String)
+        # Convert it to an array.
+        value = [value]
+      end
+
+      super(value)
+    end
+
+    def content_type
+      header['Content-Type']
+    end
+
+    def content_type=(value)
+      header['Content-Type'] = value
+    end
+
+  end
+
 end

data/lib/router.rb

@@ -1,10 +1,13 @@
-
+# Router is one of the fundamental parts of RackStep. It's the router that tell
+# us, given a path and a http verb, what controller and method should handle
+# the business logic of the request.
 module RackStep
 
   class Router
 
     # Will store all the possible routes. By default it's empty and should be
-    # populated by the application.
+    # populated by the application (RackStep will add a 404 route, the others
+    # should be added by the user).
     attr_accessor :routes
 
     def initialize
@@ -18,18 +21,18 @@ module RackStep
 
     # Given a request, will parse it's path to find what it the apropriate
     # controller and mehod/action to respond it.
-    def find_route_for(request)
-      path = request.path
+    def find_route_for(path, verb)
       # Ignoring the first char if path starts with '/'. This way the path of
       # 'http//localhost/' will be the same of 'http://localhost' (both will
       # be empty strings).
       path = path[1..-1] if path[0] == '/'
-      # Extracting the type of request (GET, POST, PUT, DELETE).
-      verb = request.request_method
       # Re-creating the route id (verb + path).
       route_id = verb + path
       # Getting the correspondent route or nil if route is invalid.
       route = routes[route_id]
+      # If no route was found, set it to 'notfound' route (maintaining the
+      # original verb).
+      route = routes["#{verb}notfound"] if route == nil
 
       return route
     end
@@ -51,7 +54,7 @@ module RackStep
       @method = method
     end
 
-    # Unique id of the route (verb + path). Eg: 'GETuser'
+    # Unique id of the route (verb + path). Eg: 'GETuser'.
     def id
       verb + path
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rackstep
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Marcio Frayze David
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-21 00:00:00.000000000 Z
+date: 2015-10-27 00:00:00.000000000 Z
 dependencies: []
 description: RackStep is (yet another) micro ruby framework for microservices and
   web development.
@@ -20,7 +20,7 @@ files:
 - lib/controller.rb
 - lib/rackstep.rb
 - lib/router.rb
-homepage: https://github.com/mfdavid/RackStep
+homepage: https://github.com/mfdavid/rackstep
 licenses:
 - MIT
 metadata: {}