rackstep 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c61f80d81dce85a8edaf0aed8f3c9a6191a335a6
-  data.tar.gz: 45afba957a83cb16b42daeb03edfd1e35507a642
+  metadata.gz: a96502606655874e6a4ff8f9d617a49a6be5b74c
+  data.tar.gz: aaed008abdfc950a191dbaacad82d25a0d5d3228
 SHA512:
-  metadata.gz: 55ddab5bb82ae17d6821fb471e015f57f7cfa35991efdbef1d74932199918b33a6f3bd9f46947905248483864f328306be47d9645ee887782ddd6f65ab7f9ca4
-  data.tar.gz: 3c939a6c913167405185302027236d64ee889a245785a394d3ca16afe126231cdad192c7dc9a22aae350cbd3824a39403bf9a0863401a05b1bc88bbcd841ae12
+  metadata.gz: d022ecba03a538210e8f92c125b291caa458dbf153ca207e90dc28c97acc0c5875ab1a8766072e4c0e0d1322ecbd5c57766ce46ef990f0bdb6a8670ed4028735
+  data.tar.gz: 9663bf5ea208d782f58d2ff6d97b8d4168ecdb6f2abed35b2cf0e0e1282326f10af5335325f923701637a58febde0e6514f6fc0dd68befae00ea3cebb7b0a230

data/lib/controller.rb

@@ -1,69 +1,79 @@
 # Abstract controller class with some helper methods. ALL your controllers
 # MUST use this one as a superclass.
 
-module RackStep
+class RackStep::Controller
 
-  class Controller
+  # The request will be injected here.
+  attr_accessor :request
 
-    # The request will be injected here.
-    attr_accessor :request
+  # The Rack::Response object that will be delivered to the user.
+  attr_accessor :response
 
-    # The Rack::Response object that will be delivered to the user.
-    attr_accessor :response
+  # The 'global' app settings will be injected here. This hash variable is
+  # initialized only once (singleton) and may contain references to things
+  # that should be initialize only once during the app start (eg: database
+  # connection).
+  attr_accessor :settings
 
-    # 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 = RackStep::Response.new
-      @response.body = ''
-      @response.content_type = 'application/json'
-      @response.status = 200
-    end
+  def initialize
+    @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
-    # processing to the specified method. The user may overwrite this method.
-    # This can be used to check for access authorization or any piece of code
-    # that must be executed before every request for this controller.
-    def before
-    end
+  # Once the application receives a new request, the router will decide wich
+  # controller should process that request and will execute this method for
+  # the chosen controller. So this is the most important method of this class
+  # and every controller should overwrite it to implement it's business
+  # logic.
+  def process_request
+  end
 
-    # 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
+  # RackStep will always execute this method before delegating the request
+  # processing to the specified controller. The user may overwrite this method.
+  # This may be usefull if the user wants to create an abstract controllers.
+  # TODO: Is this really necessary?
+  def before
+  end
 
+  # RackStep will always execute this method after processing the request
+  # of to the specified controller. 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.
+  # This may be usefull if the user wants to create an abstract controllers.
+  # TODO: Is this really necessary?
+  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
+# This is the default controller that will handle the "page not found" (404). 
+# The user may overwrite this by creating new route to 'notfound'.
+class RackStep::NotFoundController < RackStep::Controller
 
+  def process_request
+    @response.body = '404 - Page not found'
+    @response.content_type = 'text/plain'
+    @response.status  = 404
   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.
+# using Nginx or Apache or Amazon S3. 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.
+# TODO: Add layout support.
 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

data/lib/global_configuration.rb

@@ -0,0 +1,24 @@
+# A singleton class with a settings hash attribute which may be used to
+# to store all 'global' settings (eg: database connections, etc).
+# This settings variable will be injected into every controller
+# by RackStep.
+
+class RackStep::GlobalConfiguration
+
+  # One and only one instance of this class will exist. To retrieve it,
+  # we use RackStep::GlobalConfiguration.instance, but please DO NOT
+  # get it this way. The settings hash will be available to you in the 
+  # controller and you should access it with the "settings" object that
+  # is inject into your controller.
+  # To see how to use it, please take a look at sample_app.rb initialize 
+  # method and SimpleSettingsRetrieveService controller class.
+  include Singleton
+
+  attr_accessor :settings
+
+  # Defines a Hash where the settings shall be stored.
+  def initialize
+    @settings = Hash.new
+  end
+
+end

data/lib/rackstep.rb

@@ -1,40 +1,51 @@
-require_relative 'controller'
+# This is where we define an abstract class with the base of 
+# a RackStep app. This class MUST be extended by the user.
+
+require 'rack'
+require_relative 'response'
+require_relative 'route'
 require_relative 'router'
+require_relative 'global_configuration'
+require_relative 'controller'
 
 module RackStep
 
   class App
 
-    # We will store the request and create a router in this class initializer.
-    attr_reader :request, :router
+    # Will store the received request which will be injected into the user controllers.
+    attr_reader :request
 
-    # 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.
+    # 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
 
+    # Router is a singleton that will store all the registred routes.
+    def router
+      Router.instance
+    end
+
     # 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
+      @settings = RackStep::GlobalConfiguration.instance.settings
 
       # Adding default routes to handle page not found (404).
-      for_all_verbs_add_route('notfound', 'RackStep::ErrorController', 'not_found')
+      router.add_route_for_all_verbs('notfound', 'RackStep::NotFoundController')
     end
 
+    # TODO: Code Climate says this method is too big.
     def process_request
       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.
+      # In RackStep, each request is processed by a controller. The router 
+      # is responsable to find, based on the given path and http verb,
+      # the apropriate controller to handle the request.
       route = router.find_route_for(path, verb)
       # Initialize the correspondent controller.
       controller = Object.const_get(route.controller).new
@@ -45,7 +56,7 @@ module RackStep
       # Execute the before method of this controller.
       controller.send(:before)
       # Execute the apropriate method/action.
-      controller.send(route.method)
+      controller.send(:process_request)
       # Execute the after method of this controller.
       controller.send(:after)
       # Get from the controller what is the response for this request.
@@ -54,44 +65,11 @@ module RackStep
       return response
     end
 
-    # 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.
-    def add_route(verb, path, controller, method)
-      @router.add_route(verb, path, controller, method)
-    end
-
-  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
+    # This method was created to make it easier for the user to add routes, but it 
+    # will delegate to the router singleton class.
+    def self.add_route(verb, path, controller)
+      router = Router.instance
+      router.add_route(verb, path, controller)
     end
 
   end

data/lib/response.rb

@@ -0,0 +1,32 @@
+# Extending the Rack::Response class to add a few methods to make the life
+# of the developer a little easier.
+
+module RackStep
+
+  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
+
+    # Just a helper to get the content type from the response header.
+    def content_type
+      header['Content-Type']
+    end
+
+    # Just a helper to set the content type on the response header.
+    def content_type=(value)
+      header['Content-Type'] = value
+    end
+
+  end
+
+end

data/lib/route.rb

@@ -0,0 +1,24 @@
+  # Represents a single route. The verb can be 'GET', 'PUT', 'POST' or 'DELETE'.
+  # The path is a string with something like 'users', the controller is the
+  # name of the class that will process this type of request.
+
+  module RackStep
+
+    class Route
+
+      attr_accessor :verb, :path, :controller
+
+      def initialize(verb, path, controller)
+        @verb = verb
+        @path = path
+        @controller = controller
+      end
+
+      # Unique id (String) of the route (verb + path). Eg: 'GETuser'.
+      def id
+        verb + path
+      end
+
+    end
+
+end

data/lib/router.rb

@@ -1,9 +1,12 @@
 # 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.
+# us, given a path and a http verb, what controller should handle the business
+# logic of the request.
+
 module RackStep
 
   class Router
+    
+    include Singleton
 
     # Will store all the possible routes. By default it's empty and should be
     # populated by the application (RackStep will add a 404 route, the others
@@ -14,13 +17,13 @@ module RackStep
       @routes = Hash.new
     end
 
-    def add_route(verb, path, controller, method)
-      route = Route.new(verb, path, controller, method)
+    def add_route(verb, path, controller)     
+      route = Route.new(verb, path, controller)
       routes[route.id] = route
     end
 
     # Given a request, will parse it's path to find what it the apropriate
-    # controller and mehod/action to respond it.
+    # controller to respond it.
     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
@@ -37,28 +40,15 @@ module RackStep
       return route
     end
 
-  end
-
-  # Represents a single route. The verb can be 'GET', 'PUT', 'POST' or 'DELETE'.
-  # The path is a string with something like 'users', the controller is the
-  # name of the class that will process this type of request and the method
-  # parameter is the name of the method that will be executed.
-  class Route
-
-    attr_accessor :verb, :path, :controller, :method
-
-    def initialize(verb, path, controller, method)
-      @verb = verb
-      @path = path
-      @controller = controller
-      @method = method
-    end
-
-    # Unique id of the route (verb + path). Eg: 'GETuser'.
-    def id
-      verb + path
+    # Adds new routes to the application, one for each possible http verb (GET,
+    # POST, DELETE and PUT).
+    def add_route_for_all_verbs(path, controller)
+      add_route('GET', path, controller)
+      add_route('POST', path, controller)
+      add_route('DELETE', path, controller)
+      add_route('PUT', path, controller)
     end
 
   end
 
-end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rackstep
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - Marcio Frayze David
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-27 00:00:00.000000000 Z
+date: 2016-02-16 00:00:00.000000000 Z
 dependencies: []
 description: RackStep is (yet another) micro ruby framework for microservices and
   web development.
@@ -18,7 +18,10 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/controller.rb
+- lib/global_configuration.rb
 - lib/rackstep.rb
+- lib/response.rb
+- lib/route.rb
 - lib/router.rb
 homepage: https://github.com/mfdavid/rackstep
 licenses:
@@ -40,7 +43,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5.1
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: RackStep micro web framework