kwipper 0.0.1

data/lib/kwipper/application.rb

@@ -0,0 +1,87 @@
+module Kwipper
+  class Application
+    include RendersViews
+    include ControllerHelpers
+
+    attr_reader :request, :response, :action
+
+    def respond_to(request)
+      @request = request
+      @response = Response.new request
+
+      begin
+        start_time = Time.now.to_f
+        process!
+
+        log.debug "#{"Processed #{request.info}".blue} in #{sprintf '%.8f', Time.now.to_f - start_time}s"
+      rescue Kwipper::AuthenticationRequired
+        redirect '/'
+        log.debug "401 Not Authorized".yellow
+      rescue Kwipper::NotFoundError
+        render_not_found
+        log.warn @response.info.yellow
+      rescue => e
+        render_error e
+        log.fatal "#{@response.info.red}\n#{verbose_error(e)}"
+      end
+      @response
+    end
+
+    def process!
+      if Controller::ROUTES.key? request.route_key
+        response.set_status :ok
+        response.content_type = 'text/html'
+
+        controller_class, @action = Controller::ROUTES[request.route_key]
+        controller = controller_class.new request, response
+
+        if controller.respond_to? @action
+          @view = controller.process @action
+          response.body = render :layout
+        else
+          raise Kwipper::NotFoundError, "#{self} does not know #{@action}"
+        end
+      elsif (file_name = public_file_request?)
+        response.set_status :ok
+        response.content_type = get_content_type file_name
+        response.body = File.read file_name
+      else
+        raise Kwipper::NotFoundError
+      end
+    end
+
+    private
+
+    def public_file_request?
+      file = File.join(Kwipper::ROOT, 'public', request.path)
+      File.exists?(file) && file
+    end
+
+    def get_content_type(file_name)
+      if (mime = MIME::Types.of(file_name).first)
+        mime.content_type
+      else
+        log.warn "Unknown content type for file: #{file_name}"
+        'text/plain'
+      end
+    end
+
+    def render_not_found
+      response.set_status :not_found
+      response.status_message = "#{response.status_message}: #{request.info}"
+      @view = render :not_found
+      response.body = render :layout
+    end
+
+    def render_error(e)
+      @error = e
+      response.set_status :server_error
+      @view = render :server_error
+      response.body = render :layout
+    end
+
+    def verbose_error(e)
+      "#{e.class} #{e.message}\n#{e.backtrace.join "\n"}".red
+    end
+  end
+end

data/lib/kwipper/controller.rb

@@ -0,0 +1,36 @@
+module Kwipper
+  class Controller
+    include RendersViews
+    include ControllerHelpers
+
+    ROUTES = {
+      [:GET, '/'] => [self, :home]
+    }
+
+    def self.add_routes(routes)
+      routes.each do |route_key, action|
+        ROUTES.merge! route_key => [self, action]
+      end
+    end
+
+    attr_reader :app, :request, :response, :action
+
+    def initialize(request, response)
+      @request, @response = request, response
+    end
+
+    def process(action)
+      send @action = action
+    end
+
+    def home
+      render :home
+    end
+
+    protected
+
+    def require_login!
+      raise Kwipper::AuthenticationRequired unless current_session
+    end
+  end
+end

data/lib/kwipper/controller_helpers.rb

@@ -0,0 +1,22 @@
+module Kwipper
+  module ControllerHelpers
+    protected
+    
+    def params
+      request.params
+    end
+
+    def redirect(path, status = :found)
+      response.redirect = path
+      response.set_status status
+    end
+
+    def current_user
+      response.current_user
+    end
+
+    def current_session
+      response.current_session
+    end
+  end
+end

data/lib/kwipper/errors.rb

@@ -0,0 +1,5 @@
+module Kwipper
+  AuthenticationRequired = Class.new RuntimeError
+  NotFoundError = Class.new RuntimeError
+  EmptyRequest = Class.new RuntimeError
+end

data/lib/kwipper/http_parser.rb

@@ -0,0 +1,51 @@
+module Kwipper
+  class HttpParser
+    HEADER_DELIMITER = "\r\n"
+
+    def parse(raw_request)
+      @first_line = raw_request.gets
+
+      if @first_line.nil?
+        raise Kwipper::EmptyRequest, 'could not get first line'
+      else
+        Request.new do |r|
+          r.http_method = @first_line.split(' ').first
+          r.path      = parse_path
+          r.query     = parse_query
+          r.headers   = parse_headers raw_request
+          r.post_data = parse_query_string raw_request.read(r.content_length) if r.post_data?
+        end
+      end
+    end
+
+    private
+
+    def parse_path
+      p = @first_line.split(' ')[1]
+      p ? p.split('?').first : '/'
+    end
+
+    def parse_query
+      p = @first_line.split(' ')[1]
+      q = p && !p['?'].nil? ? p.split('?').last.chomp : nil
+      parse_query_string q
+    end
+
+    def parse_headers(raw_request)
+      lines = []
+
+      while (line = raw_request.gets) != HEADER_DELIMITER
+        lines << line.chomp
+      end
+
+      lines.each_with_object RequestHeaders.new do |line, request_headers|
+        key, val = line.split(/:\s?/)
+        request_headers[key] = val
+      end
+    end
+
+    def parse_query_string(s)
+      Rack::Utils.parse_nested_query s.to_s
+    end
+  end
+end

data/lib/kwipper/http_server.rb

@@ -0,0 +1,61 @@
+module Kwipper
+  class HttpServer < TCPServer
+    DEFAULT_PORT = 80
+    attr_reader :host
+
+    def self.run(bind = '127.0.0.1', port = 7335)
+      HttpServer.new(bind, port).serve
+    end
+
+    def initialize(bind = '127.0.0.1', port = 7335)
+      @bind, @port = bind, port
+      @host = "#@bind#{":#@port" unless port.to_i == DEFAULT_PORT}"
+      log.debug "Starting server on #@host"
+      super
+    end
+
+    def serve
+      load_models
+      load_controllers
+      parser = HttpParser.new
+      Kwipper.log_startup_time
+
+      while socket = accept
+        begin
+          request = parser.parse socket
+
+          log.info "#{request.info} #{request.params.inspect unless request.params.empty?}".strip.green
+
+          response = Application.new.respond_to request
+          socket.write response.to_http_response
+
+        rescue Errno::ECONNRESET, Errno::EPIPE => e
+          log.info "#{e.class} #{e.message}".yellow
+        rescue Kwipper::EmptyRequest => e
+          log.warn "#{e.class} #{e.message}".yellow
+        ensure
+          socket.close
+        end
+      end
+
+    rescue Interrupt
+      socket.close if socket && !socket.closed?
+      Model.db.close
+      log.debug "Ok bye."
+    end
+
+    private
+
+    def load_models
+      Dir[File.join(Kwipper::ROOT, 'app/models/**/*.rb')].each do |model|
+        require model
+      end
+    end
+
+    def load_controllers
+      Dir[File.join(Kwipper::ROOT, 'app/controllers/**/*.rb')].each do |controller|
+        require controller
+      end
+    end
+  end
+end

data/lib/kwipper/inflect.rb

@@ -0,0 +1,19 @@
+module Kwipper
+  class Inflect < String
+    def self.plural(count, word)
+      "#{count} #{count > 1 ? new(word).pluralize : word}"
+    end
+
+    def demodulize
+      Inflect.new split('::').last
+    end
+
+    def pluralize
+      Inflect.new chars.last == 's' ? self : "#{self}s"
+    end
+
+    def underscore
+      Inflect.new gsub(/[a-z]([A-Z])/) { |m| m.gsub $1, "_#{$1}" }.downcase
+    end
+  end
+end

data/lib/kwipper/model.rb

@@ -0,0 +1,174 @@
+module Kwipper
+  class Model
+    DB_NAME = 'kwipper'
+    DB_FILE_NAME = "#{DB_NAME}.db"
+    ID_COLUMN = 'id'
+
+    UnknownAttribute = Class.new ArgumentError
+
+    class << self
+      def db
+        @db ||= SQLite3::Database.open File.join(Kwipper::ROOT, 'db', DB_FILE_NAME)
+      end
+
+      # Declare columns in the model subclass in the same order the columns
+      # were created in the table. This lets us instantiate model objects
+      # from arrays of field values from the db. ID columns is defaulted.
+      def column(name, type)
+        @columns ||= { ID_COLUMN => :to_i }
+        @columns[name] = type
+        attr_accessor name
+      end
+      attr_reader :columns
+
+      # All SQL statements should be executed through this method
+      def sql(cmd)
+        start_time = Time.now.to_f
+        db.execute(cmd).tap do
+          log.debug "#{cmd.red} in #{sprintf '%.8f', Time.now.to_f - start_time}s"
+        end
+      end
+
+      # Get records from a single table and instantiate them
+      def all(statement = "SELECT * FROM #{table_name}")
+        sql(statement).each_with_object [] do |attrs, models|
+          models << new(attr_array_to_hash attrs)
+        end
+      end
+
+      def find(id)
+        where(id: id).first
+      end
+
+      def where(attrs)
+        all "SELECT * FROM #{table_name} WHERE #{hash_to_key_vals attrs}"
+      end
+
+      def create(attrs)
+        db_attrs = attrs.map { |k, v| normalize_value_for_db v, columns[k] }
+
+        unless attrs.key? 'id'
+          id = generate_id
+          attrs['id'] = id
+          db_attrs = [id, *db_attrs]
+        end
+
+        sql "INSERT INTO #{table_name} VALUES(#{db_attrs.join ', '})"
+        new attrs
+      end
+
+      def update(id, attrs)
+        sql "UPDATE #{table_name} SET #{hash_to_key_vals attrs} WHERE id=#{id}"
+      end
+
+      def destroy(id)
+        sql "DELETE FROM #{table_name} WHERE id=#{id}"
+      end
+
+      def exists?(id)
+        id = normalize_value_for_db id, columns['id']
+        result = sql "SELECT id FROM #{table_name} WHERE id = #{id} LIMIT 1"
+        result.first && result.first.any?
+      end
+
+      def count(statement = "SELECT COUNT(id) FROM #{table_name}")
+        sql(statement).first.first
+      end
+    end
+
+    attr_accessor :id
+
+    # Takes a hash of model attributes and sets them via accessors if they exists
+    def initialize(attrs = {})
+      attrs.keys.each do |name|
+        if self.class.columns.keys.include? name
+          type = self.class.columns[name]
+          send "#{name}=", attrs[name].send(type)
+        else
+          raise UnknownAttribute, "#{name} for #{self}"
+        end
+      end
+    end
+
+    # Saves model instance to the database
+    def save
+      if id
+        self.class.update id, attrs_for_db
+      else
+        self.class.create a = attrs_for_db
+        @id ||= a['id']
+      end
+
+      true
+    rescue SQLite3::SQLException => e
+      log.warn e.message
+      false
+    end
+
+    def update(attrs)
+      self.class.update id, attrs
+      true
+    rescue KeyError => e
+      false
+    end
+
+    def destroy(id)
+      self.class.destroy id
+    end
+
+    def sql(statement)
+      self.class.sql statement
+    end
+
+    private
+
+    def attrs_for_db
+      self.class.columns.each_with_object({}) do |(name, _), attrs|
+        value = send name
+        value = generate_id if name == ID_COLUMN && value.nil?
+        attrs[name] = value unless value.nil?
+      end
+    end
+
+    def generate_id
+      self.class.generate_id
+    end
+
+    class << self
+      def table_name
+        Inflect.new(name).demodulize.pluralize.underscore
+      end
+
+      def generate_id
+        max_id_plus_1 = "SELECT (id + 1) as id FROM #{table_name} ORDER BY id DESC LIMIT 1"
+        result = sql(max_id_plus_1).first
+        result && result.first ? result.first : 1
+      end
+
+      def attr_array_to_hash(attrs)
+        attrs.each_with_index.inject({}) do |hash, (attr_val, i)|
+          hash.merge! @columns.keys[i] => attr_val
+        end
+      end
+
+      # Turn a hash of attributes into a comma separated string that's
+      # safe to use in a SQL statement (non int values are quoted).
+      # TODO: add SQL sanitation.
+      def hash_to_key_vals(hash)
+        hash.inject [] do |a, (k, v)|
+          v = normalize_value_for_db v, columns[k]
+          a << "#{k}=#{v}"
+        end.join ', '
+      end
+
+      # Non int values should be quoted when putting in a SQL statement
+      def normalize_value_for_db(value, type)
+        case type when :to_i
+          value.to_i
+        else
+          "\"#{value}\""
+        end
+      end
+    end
+  end
+end