expressr 0.0.2 → 0.0.3

data/lib/expressr.rb

@@ -1,4 +1,10 @@
-require "#{directory}/expressr/version.rb"
+require 'mime-types'
+require 'hashie'
+require 'noder'
+
+directory = File.dirname(File.absolute_path(__FILE__))
+Dir.glob("#{directory}/expressr/*.rb") { |file| require file }
+Dir.glob("#{directory}/expressr/listeners/*.rb") { |file| require file }
 
 module Expressr
 end

data/lib/expressr/app.rb

@@ -0,0 +1,108 @@
+require 'pathname'
+
+module Expressr
+  class App
+    extend Forwardable
+
+    attr_reader :router, :server
+
+    def_delegators :@router, :put, :post, :delete, :use, :route
+
+    DEFAULTS = {
+      'jsonp callback name' => 'callback',
+      'locals' => {},
+      'root' => nil,
+      'view engine' => 'slim',
+      'views' => 'views'
+    }
+    
+    class << self
+      def settings
+        @settings ||= DEFAULTS
+      end
+    end
+
+    def initialize(server_options={})
+      @router = Router.new
+      @locals = {}
+      set_default_root
+      @server_options = { app: self }.merge(server_options)
+      @server = Noder::HTTP::Server.new(@server_options)
+      @router.server = @server
+      request_stack = @server.event_stack('request')
+      request_stack.replace(Noder::HTTP::Listeners::Request, callback: Expressr::Listeners::Request)
+      request_stack.replace(Noder::HTTP::Listeners::Response, callback: Expressr::Listeners::Response)
+    end
+
+    def set(name, value)
+      settings[name] = value
+    end
+
+    def get(name_or_path, &block)
+      if block
+        @router.get(name_or_path, &block)
+      else
+        settings[name_or_path]
+      end
+    end
+
+    def enable(name)
+      settings[name] = true
+    end
+
+    def disable(name)
+      settings[name] = false
+    end
+
+    def enabled?(name)
+      settings[name] == true
+    end
+
+    def disabled?(name)
+      settings[name] == false
+    end
+
+    def engine(value)
+      set('view engine', value)
+    end
+
+    def param(name, &block)
+      @router.add_route(block, param: name)
+    end
+
+    def all(path, &block)
+      @router.add_route(block, path: path)
+    end
+
+    def locals
+      settings['locals']
+    end
+
+    def render(view, options={}, &block)
+      raise NotImplementedError
+    end
+
+    def listen(port=nil, address=nil, &block)
+      @server_options[:port] = port if port
+      @server_options[:address] = address if address
+      @server.listen(@server_options[:port], @server_options[:address], {}, &block)
+    end
+
+    def close
+      @server.close
+    end
+
+    def settings
+      self.class.settings
+    end
+
+    private
+
+    def set_default_root
+      return if get('root')
+      caller_path = caller[1].split(':')[0]
+      caller_directory = File.dirname(caller_path)
+      set('root', Pathname.new(caller_directory))
+    end
+  end
+end

data/lib/expressr/json.rb

@@ -0,0 +1,15 @@
+require 'json'
+
+module Expressr
+  class JSON
+    class << self
+      def decode(string)
+        ::JSON.load(string)
+      end
+
+      def encode(value)
+        ::JSON.dump(value)
+      end
+    end
+  end
+end

data/lib/expressr/listeners/request.rb

@@ -0,0 +1,11 @@
+module Expressr
+  module Listeners
+    class Request < Noder::Events::Listeners::Base
+      def call(env)
+        env[:request] = Expressr::Request.new(env[:request_env])
+        callback.call(env) if callback
+        env
+      end
+    end
+  end
+end

data/lib/expressr/listeners/response.rb

@@ -0,0 +1,11 @@
+module Expressr
+  module Listeners
+    class Response < Noder::Events::Listeners::Base
+      def call(env)
+        env[:response] = Expressr::Response.new(env)
+        callback.call(env) if callback
+        env
+      end
+    end
+  end
+end

data/lib/expressr/renderer.rb

@@ -0,0 +1,39 @@
+module Expressr
+  class Renderer
+    class << self
+      attr_accessor :engine
+
+      def renderer
+        if engine != Expressr::App.settings['view engine']
+          @renderer = get_renderer
+        else
+          @renderer ||= get_renderer
+        end
+      end
+
+      def get_renderer
+        self.engine = engines[Expressr::App.settings['view engine']]
+        raise "Invalid view engine value: #{engine}" unless engine
+        klass = Expressr::Utils.constantize(engine)
+        klass.new
+      end
+
+      def engines
+        {
+          'haml' => 'Expressr::Renderers::Haml',
+          'slim' => 'Expressr::Renderers::Slim'
+        }
+      end
+    end
+
+    def render(path, locals={})
+      path = App.settings['root'].join(App.settings['views'], path)
+      locals = App.settings['locals'].merge(locals)
+      renderer.render(path, locals)
+    end
+
+    def renderer
+      self.class.renderer
+    end
+  end
+end

data/lib/expressr/renderers.rb

@@ -0,0 +1,9 @@
+module Expressr
+  module Renderers
+    directory = "#{File.dirname(File.absolute_path(__FILE__))}/renderers"
+
+    autoload :Base, "#{directory}/base"
+    autoload :Haml, "#{directory}/haml"
+    autoload :Slim, "#{directory}/slim"
+  end
+end

data/lib/expressr/renderers/base.rb

@@ -0,0 +1,10 @@
+module Expressr
+  module Renderers
+    class Base
+      def add_extension(path, extension)
+        return "#{path}.#{extension}" if path.extname == ''
+        path
+      end
+    end
+  end
+end

data/lib/expressr/renderers/haml.rb

@@ -0,0 +1,13 @@
+module Expressr
+  module Renderers
+    class Haml < Base
+      require 'haml'
+
+      def render(view, locals={})
+        view = add_extension(view, 'haml')
+        content = File.read(view)
+        ::Haml::Engine.new(content).render(nil, locals)
+      end
+    end
+  end
+end

data/lib/expressr/renderers/slim.rb

@@ -0,0 +1,12 @@
+module Expressr
+  module Renderers
+    class Slim < Base
+      require 'slim'
+
+      def render(view, locals={})
+        view = add_extension(view, 'slim')
+        ::Slim::Template.new(view).render(nil, locals)
+      end
+    end
+  end
+end

data/lib/expressr/request.rb

@@ -0,0 +1,118 @@
+module Expressr
+  class Request < Noder::HTTP::Request
+    attr_reader :query
+
+    def initialize(env)
+      super(env)
+      @params = Hashie::Mash.new(@params)
+      @query = Hashie::Mash.new(@query)
+    end
+
+    def url
+      @url ||= original_url
+    end
+
+    def param(name)
+      params[name]
+    end
+
+    def route
+      raise NotImplementedError
+    end
+
+    def cookies
+      raise NotImplementedError
+    end
+
+    def signed_cookies
+      raise NotImplementedError
+    end
+
+    def get(name)
+      headers[name]
+    end
+
+    def accepts(types)
+      types = types.split(', ') if types.is_a?(String)
+      types = [types] unless types.is_a?(Array)
+      @accept_types ||= get('Accept').split(';').first.split(',')
+      (types & @accept_types).first
+    end
+
+    def accepts_charset(charset)
+      raise NotImplementedError
+    end
+
+    def accepts_language(language)
+      raise NotImplementedError
+    end
+
+    def is?(type)
+      content_type_header = headers['Content-Type']
+      return false if content_type_header.nil?
+      content_types = content_type_header.split('; ')
+      content_types.include?(type)
+    end
+
+    def ip
+      @env[:ip]
+    end
+
+    def ips
+      raise NotImplementedError
+    end
+
+    def path
+      @env[:request_uri]
+    end
+
+    def host
+      get('Host').split(':').first
+    end
+
+    def fresh?
+      raise NotImplementedError
+    end
+
+    def stale?
+      raise NotImplementedError
+    end
+
+    def xhr?
+      get('X-Requested-With') == 'XMLHttpRequest'
+    end
+
+    def protocol
+      @env[:protocol].split('/').first.downcase
+    end
+
+    def secure?
+      protocol == 'https'
+    end
+
+    def subdomains
+      host.split('.')[0..-3].reverse
+    end
+
+    def locals
+      @locals ||= Hashie::Mash.new
+    end
+
+    def original_url
+      @original_url ||= get_original_url
+    end
+
+    protected
+
+    def get_original_url
+      url = path
+      query_string = @env[:query_string]
+      if query_string && query_string != ''
+        url = "#{url}?#{query_string}"
+      end
+      url
+    end
+
+    alias_method :header, :get
+  end
+end

data/lib/expressr/response.rb

@@ -0,0 +1,188 @@
+require 'cgi'
+
+module Expressr
+  class Response < Noder::HTTP::Response
+    DEFAULT_STATUS = 200
+
+    attr_accessor :cookies, :locals, :status
+    attr_reader :request
+
+    def initialize(env)
+      super(env)
+      @request = env[:request]
+      @cookies = {}
+    end
+
+    # Defining #status(status) conflicts with EventMachine::DelegatedHttpResponse's #status
+
+    def set(key_or_hash, value=nil)
+      if key_or_hash.is_a?(Hash)
+        hash = key_or_hash
+        hash.each do |key, value|
+          set_header(key, value)
+        end
+      else
+        key = key_or_hash
+        set_header(key, value)
+      end
+    end
+
+    def get(key)
+      get_header(key)
+    end
+
+    def cookie(name, value, options={})
+      options = { 'name' => name, 'value' => value }.merge(options)
+      @cookies[name] = CGI::Cookie::new(options)
+      set_cookies
+    end
+
+    def clear_cookie(name, options={})
+      cookie(name, '', options)
+    end
+
+    def redirect(status_or_url, url=nil)
+      if url
+        status = status_or_url
+      else
+        status = 302
+        url = status_or_url
+      end
+      write_head(status)
+      location(url)
+      self.end
+    end
+
+    def location(url)
+      set_header('Location', url)
+    end
+
+    # Equivalent of Express.js's send
+    def out(status_or_content=nil, content=nil)
+      if status_or_content.is_a?(Integer)
+        status = status_or_content
+      else
+        status = DEFAULT_STATUS
+        content = status_or_content || ''
+      end
+      if content.is_a?(Hash) || content.is_a?(Array)
+        json(status, content)
+      else
+        type('text/html') unless get('Content-Type')
+        write_head(status)
+        write(content)
+        self.end
+      end
+    end
+
+    def json(status_or_body, body=nil)
+      if status_or_body.is_a?(Integer)
+        status = status_or_body
+      else
+        status = DEFAULT_STATUS
+        body = status_or_body
+      end
+      type('application/json')
+      write_head(status)
+      write(Expressr::JSON.encode(body))
+      self.end
+    end
+
+    def jsonp(status_or_body, body=nil)
+      callback_name = Expressr::App.settings['jsonp callback name']
+      callback = params[callback_name]
+      if callback.nil?
+        json(status_or_body, body)
+        return
+      end
+      if status_or_body.is_a?(Integer)
+        status = status_or_body
+      else
+        status = DEFAULT_STATUS
+        body = status_or_body
+      end
+      type('application/javascript')
+      write_head(status)
+      body = Expressr::JSON.encode(body)
+      body = "#{callback}(#{body});"
+      write(body)
+      self.end
+    end
+
+    def type(value)
+      set_header('Content-Type', value)
+    end
+
+    def format(hash)
+      hash.each do |content_type, proc|
+        content_type = Utils.standardize_content_type(content_type)
+        if request.accepts(content_type)
+          proc.call(@request, self)
+        end
+      end
+    end
+
+    def attachment(filename=nil)
+      content_disposition = 'attachment'
+      if filename
+        basename = File.basename(filename)
+        content_disposition += %Q|; filename="#{basename}"|
+        content_type = MIME::Types.type_for(filename).first.to_s
+        type(content_type)
+      end
+      set_header('Content-Disposition', content_disposition)
+    end
+
+    def send_file(path, options={})
+      root = nil
+      if options[:root] && !path.start_with?('/')
+        root = Pathname.new(options[:root])
+      elsif App.settings['root']
+        root = App.settings['root']
+      end
+      path = root.join(path).to_s if root
+      attachment(path) unless options[:bypass_headers]
+      write(read_file(path))
+      self.end
+    end
+
+    def download(path, filename=nil)
+      attachment(filename || path)
+      send_file(path, bypass_headers: true)
+    end
+
+    def links(links)
+      value = links.map { |key, url| %Q|<#{url}>; rel="#{key}"| }.join(', ')
+      set_header('Link', value)
+    end
+
+    def locals
+      @locals ||= {}
+    end
+
+    def render(view, locals=nil, &block)
+      body = nil
+      begin
+        body = Renderer.new.render(view, locals)
+      rescue Exception => e
+        if block
+          block.call(e)
+        else
+          raise
+        end
+      end
+      out(body)
+    end
+
+    protected
+
+    def read_file(path)
+      File.open(path, 'rb').read
+    end
+
+    def set_cookies
+      cookie_string = @cookies.values.map(&:to_s).join("\nSet-Cookie: ")
+      set_header('Set-Cookie', cookie_string)
+    end
+  end
+end