laris 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 38b0b2681b75e2aad93d4c3c678131d46b08f61c
+  data.tar.gz: d64820d9c71788474c8dadd23172a555c6b1aff6
+SHA512:
+  metadata.gz: db0c1085ad333187cc821e260151e6a49bd3e3802253042609fc866d76fc18cd759859e1c780428ef97a770d2acd2c9c976db99bb97230cf9d98f84ff2efe1c1
+  data.tar.gz: 94df81f213657b6233ec2ecd7af02f0b039bada81bdc430e6d272e161cb4b3cdf2361da4ee7fc6974bfc19786e64bc8bd1b646d9a4cda32833ae726f59ba24b7

data/README.md

@@ -0,0 +1,101 @@
+#Laris
+
+A lightweight MVC framework inspired by Ruby on Rails.
+
+To see it in action, check out my minesweeper game: [live][minesweeper]	•  [github][minesweeper-github]
+
+[minesweeper]: http://minesweepers.herokuapp.com
+[minesweeper-github]: http://github.com/composerinteralia/minesweeper/
+
+##Getting Started
+* `gem install laris`
+* Put sql files in `db/migrations/` numbered in the order you want them to be
+executed (NB I need to add a rake task for migrating. At the moment you will
+need to run `DBConnection.migrate` yourself)
+* Create models in app/models/
+
+```rb
+# app/models/post.rb
+
+class Post < LarisrecordBase
+  belongs_to :author, class_name: "User", foreign_key: :user_id
+end
+```
+
+* Construct routes using a regex, controller name, and method name
+
+```rb
+# config/routes.rb
+
+ROUTER.draw do
+  get Regexp.new("^/users$"), UsersController, :index
+  get Regexp.new("^/users/new$"), UsersController, :new
+  post Regexp.new("^/users$"), UsersController, :create
+  get Regexp.new("^/users/(?<id>\\d+)$"), UsersController, :show
+  get Regexp.new("^/users/(?<id>\\d+)/edit$"), UsersController, :edit
+  patch Regexp.new("^/users/(?<id>\\d+)$"), UsersController, :update
+  delete Regexp.new("^/users/(?<id>\\d+)$"), UsersController, :destroy
+end
+```
+
+* Add controllers in app/controllers/
+
+```rb
+# app/controllers/users_controller.rb
+
+class UsersController < ControllerBase
+  def index
+    @users = User.all
+
+    render :index
+  end
+end
+```
+
+* Create erb views in app/views/<controller>
+
+```
+# app/views/users/index.html.erb
+
+<ul>
+  <% @users.each do |user| %>
+    <li><%= user.name %></li>
+  <% end %>
+</ul>
+```
+
+* Place any assets in app/assets
+* You will need a database URL to run locally (yeah, I have work to do). If you
+are feeling adventurous, you can use your Heroku database URL, but probably you shouldn't...
+
+```sh
+export DATABASE_URL=$(heroku config -s | grep DATABASE_URL | sed -e "s/^DATABASE_URL='//" -e "s/'//")
+```
+
+* Add these to the root of your project:
+
+```rb
+# laris.ru
+
+require 'laris'
+Laris.root = File.expand_path(File.dirname(__FILE__))
+
+require_relative 'config/routes'
+
+run Laris.app
+```
+
+```
+# Procfile
+
+web: bundle exec rackup laris.ru -p $PORT
+```
+
+* Start up your app with `bundle exec rackup laris.ru` or push to Heroku
+* You did it!
+
+## TODO
+* Database config file
+* Rake task for migrations
+* Migrations in Ruby, not raw SQL
+* `laris new`

data/lib/laris.rb

@@ -0,0 +1,41 @@
+require 'active_support'
+require 'active_support/core_ext'
+require 'active_support/inflector'
+require 'cgi'
+require 'erb'
+require 'json'
+require 'pg'
+require 'rack'
+require 'uri'
+
+require 'laris/asset_server'
+require 'laris/autoloader'
+require 'laris/controller'
+require 'laris/exception_viewer'
+require 'laris/larisrecord'
+require 'laris/router'
+
+module Laris
+  VERSION = '0.0.0'
+
+  def self.app
+    DBConnection.open
+
+    app = Proc.new do |env|
+      req = Rack::Request.new(env)
+      res = Rack::Response.new
+      Laris::Router.run(req, res)
+      res.finish
+    end
+
+    Rack::Builder.new do
+      use ExceptionViewer
+      use AssetServer
+      run app
+    end
+  end
+
+  def self.root=(root)
+    const_set(:ROOT, root)
+  end
+end

data/lib/laris/asset_server.rb

@@ -0,0 +1,30 @@
+class AssetServer
+  attr_reader :app, :res
+
+  def initialize(app)
+    @app = app
+    @res = Rack::Response.new
+  end
+
+  def call(env)
+    req = Rack::Request.new(env)
+    if req.path =~ (/^\/assets/)
+      respond_with_asset(req)
+    else
+      app.call(env)
+    end
+  end
+
+  private
+  def respond_with_asset(req)
+    dir_path = File.dirname(__FILE__)
+    path = File.join(Laris::ROOT, "app", req.path)
+
+    ext = File.extname(path)
+    ext = ".json" if ext == ".map"
+    res["Content-Type"] = Rack::Mime::MIME_TYPES[ext]
+
+    res.write(File.read(path))
+    res.finish
+  end
+end

data/lib/laris/autoloader.rb

@@ -0,0 +1,34 @@
+module Laris
+  AUTOLOAD_PATHS = [
+    "app/models",
+    "app/controllers",
+  ]
+end
+
+class Object
+  def self.const_missing(const)
+    auto_load(const)
+    Kernel.const_get(const)
+  end
+
+  private
+  def auto_load(const)
+    Laris::AUTOLOAD_PATHS.each do |folder|
+      file = File.join(Laris::ROOT, folder, const.to_s.underscore)
+      return if try_auto_load(file)
+    end
+  end
+
+  def try_auto_load(file)
+    require_relative(file)
+    return true
+  rescue LoadError
+    false
+  end
+end
+
+class Module
+  def const_missing(const)
+    Object.const_missing(const)
+  end
+end

data/lib/laris/controller.rb

@@ -0,0 +1,8 @@
+require_relative 'controller/controller_base'
+require_relative 'controller/csrf'
+require_relative 'controller/flash'
+require_relative 'controller/session'
+
+class ControllerBase
+  include CSRF
+end

data/lib/laris/controller/controller_base.rb

@@ -0,0 +1,90 @@
+class ControllerBase
+  class DoubleRenderError < StandardError
+    def message
+      "Render and/or redirect_to were called multiple times in a single action."
+    end
+  end
+
+  attr_reader :req, :res, :params
+
+  def initialize(req, res, params = {})
+    @req = req
+    @res = res
+    @params = params.merge(req.params)
+
+    body = req.body.read
+    if body =~ /^{.*}$/
+      @params.merge!(JSON.parse(body))
+    end
+  end
+
+  def already_built_response?
+    @already_built_response
+  end
+
+  def h(text)
+    CGI::escapeHTML(text)
+  end
+
+  def redirect_to(url)
+    raise DoubleRenderError if already_built_response?
+
+    res['Location'] = url
+    res.status = 302
+    store_cookies(res)
+
+    @already_built_response = true
+  end
+
+  def render_content(content, content_type)
+    raise DoubleRenderError if already_built_response?
+
+    res['Content-Type'] = content_type
+    res.write(content)
+    store_cookies(res)
+
+    @already_built_response = true
+  end
+
+  def render(template_name)
+    path = File.join(
+      Laris::ROOT,
+      'app/views',
+      controller_name.remove("_controller"),
+      "#{template_name}.html.erb",
+    )
+
+    template = File.read(path)
+    content = ERB.new(template).result(binding)
+
+    render_content(content, "text/html")
+  end
+
+  def session
+    @session ||= Session.new(req)
+  end
+
+  def flash
+    @flash ||= Flash.new(req)
+  end
+
+  def invoke_action(name, method)
+    unless method == :get || req.xhr?
+      verify_authenticity
+    end
+
+    self.send(name)
+    render(name) unless already_built_response?
+  end
+
+  private
+    def store_cookies(req)
+      set_session_auth_token
+      session.store_session(res)
+      flash.store_flash(res)
+    end
+
+    def controller_name
+      self.class.name.underscore
+    end
+end

data/lib/laris/controller/csrf.rb

@@ -0,0 +1,24 @@
+module CSRF
+  def form_authenticity_token
+    @token ||= SecureRandom.urlsafe_base64
+  end
+
+  def verify_authenticity
+    unless session_auth_token == form_auth_token
+      raise "Invalid Authenticity Token"
+    end
+  end
+
+  private
+  def form_auth_token
+    params['authenticity_token']
+  end
+
+  def set_session_auth_token
+    session['authenticity_token'] = form_authenticity_token
+  end
+
+  def session_auth_token
+    session['authenticity_token']
+  end
+end

data/lib/laris/controller/flash.rb

@@ -0,0 +1,39 @@
+class Flash
+  attr_reader :stale_cookie, :fresh_cookie
+
+  def initialize(req)
+    raw_cookie = req.cookies['_laris_flash']
+    @stale_cookie = raw_cookie ? JSON.parse(raw_cookie) : {}
+    @fresh_cookie = {}
+    @persistent = true
+  end
+
+  def persistent?
+    @persistent
+  end
+
+  def now
+    @persistent = false
+    self
+  end
+
+  def [](key)
+    fresh_cookie.merge(stale_cookie)[key]
+  end
+
+  def []=(key, val)
+    if persistent?
+      fresh_cookie[key] = val
+    else
+      stale_cookie[key] = val
+    end
+
+    @persistent = true
+    val
+  end
+
+  def store_flash(res)
+    new_cookie = { path: '/', value: fresh_cookie.to_json }
+    res.set_cookie('_laris_flash', new_cookie)
+  end
+end

data/lib/laris/controller/session.rb

@@ -0,0 +1,21 @@
+class Session
+  attr_reader :cookie
+
+  def initialize(req)
+    raw_cookie = req.cookies['_laris_session']
+    @cookie = raw_cookie ? JSON.parse(raw_cookie) : {}
+  end
+
+  def [](key)
+    cookie[key]
+  end
+
+  def []=(key, val)
+    cookie[key] = val
+  end
+
+  def store_session(res)
+    new_cookie = { path: '/', value: cookie.to_json }
+    res.set_cookie('_laris_session', new_cookie)
+  end
+end

data/lib/laris/exception_view.html.erb

@@ -0,0 +1,15 @@
+<h2>WTF!</h2>
+
+<h4><%= CGI::escapeHTML(message) %></h4>
+
+<pre>
+  <%= code_preview %>
+</pre>
+
+<ul>
+  <% backtrace.each do |line| %>
+    <li>
+      <%= CGI::escapeHTML(line) %><br>
+    </li>
+  <% end %>
+</ul>

data/lib/laris/exception_viewer.rb

@@ -0,0 +1,60 @@
+class ExceptionViewer
+  attr_reader :app, :exception, :res
+
+  def initialize(app)
+    @app = app
+    @res = Rack::Response.new
+    @exception = nil
+  end
+
+  def call(env)
+    begin
+      app.call(env)
+    rescue => e
+      @exception = e
+      exception_page
+    end
+  end
+
+  private
+  def exception_page
+    res.status = 500
+    res["Content-Type"] = "text/html"
+    res.write(content)
+    res.finish
+  end
+
+  def content
+    template = File.read("#{File.dirname(__FILE__)}/exception_view.html.erb")
+    ERB.new(template).result(binding)
+  end
+
+  def backtrace
+    exception.backtrace
+  end
+
+  def source
+    backtrace.first
+  end
+
+  def message
+    exception.message
+  end
+
+  def code_preview
+    match_data = source.match(/^(.+):(\d+)(:in.+)?$/)
+    file_name, line = match_data.captures
+
+    lines = File.readlines(file_name).map(&:chomp)
+    i = line.to_i - 1
+
+    lines[i] << "<b> <---------- What were you thinking?</b>"
+
+    3.times do
+      i -= 1 if i > 0
+    end
+
+    lines[i, 6].join('<br>')
+  end
+
+end

data/lib/laris/larisrecord.rb

@@ -0,0 +1,15 @@
+require_relative 'larisrecord/associatable'
+require_relative 'larisrecord/db_connection'
+require_relative 'larisrecord/larisrecord_base'
+require_relative 'larisrecord/relation'
+require_relative 'larisrecord/searchable'
+
+class LarisrecordBase
+  extend Associatable
+  extend Searchable
+end
+
+TracePoint.new(:end) do |tp|
+  klass = tp.binding.receiver
+  klass.laris_finalize! if klass.respond_to?(:laris_finalize!)
+end.enable

data/lib/laris/larisrecord/associatable.rb

@@ -0,0 +1,101 @@
+class AssocOptions
+  attr_accessor :class_name, :foreign_key, :primary_key
+
+  def model_class
+    class_name.constantize
+  end
+
+  def table_name
+    model_class.table_name
+  end
+end
+
+class BelongsToOptions < AssocOptions
+  def initialize(assoc_name, options = {})
+    defaults = {
+      class_name: assoc_name.to_s.camelcase,
+      foreign_key: "#{assoc_name}_id".to_sym,
+      primary_key: :id
+    }
+
+    defaults.each do |attr, default|
+      send("#{attr}=", (options[attr] || default))
+    end
+  end
+end
+
+class HasManyOptions < AssocOptions
+  def initialize(assoc_name, self_name, options = {})
+    defaults = {
+      class_name: assoc_name.to_s.singularize.camelcase,
+      foreign_key: "#{self_name.underscore}_id".to_sym,
+      primary_key: :id
+    }
+
+    defaults.each do |attr, default|
+      send("#{attr}=", (options[attr] || default))
+    end
+  end
+end
+
+module Associatable
+  def belongs_to(assoc_name, options = {})
+    options = BelongsToOptions.new(assoc_name, options)
+    assoc_options[assoc_name] = options
+
+    define_method(assoc_name) do
+      klass = options.model_class
+      foreign_key_value = send(options.foreign_key)
+      primary_key = options.primary_key
+
+      klass.where(primary_key => foreign_key_value).first
+    end
+  end
+
+  def has_many(assoc_name, options = {})
+    options = HasManyOptions.new(assoc_name, self.name, options)
+
+    define_method(assoc_name) do
+      klass = options.model_class
+      foreign_key = options.foreign_key
+      primary_key_value = send(options.primary_key)
+
+      klass.where(foreign_key => primary_key_value)
+    end
+  end
+
+  def assoc_options
+    @assoc_options ||= {}
+  end
+
+  def has_one_through(assoc_name, through_name, source_name)
+    define_method(assoc_name) do
+      through_options = assoc_options[through_name]
+      through_klass = through_options.model_class
+      through_table = through_klass.table_name
+      through_fk_value = send(through_options.foreign_key)
+      through_pk = through_options.primary_key
+
+      source_options = through_klass.assoc_options[source_name]
+      source_klass = source_options.model_class
+      source_table = source_klass.table_name
+      source_fk = source_options.foreign_key
+      source_pk = source_options.primary_key
+
+      result = DBConnection.execute(<<-SQL, through_fk_value)
+        SELECT
+          #{source_table}.*
+        FROM
+          #{through_table}
+        JOIN
+          #{source_table}
+        ON
+          #{through_table}.#{source_fk} = #{source_table}.#{source_pk}
+        WHERE
+          #{through_table}.#{through_pk} = ?
+      SQL
+
+      source_klass.new(result.first)
+    end
+  end
+end

data/lib/laris/larisrecord/db_connection.rb

@@ -0,0 +1,105 @@
+class DBConnection
+  def self.open
+    uri = URI.parse(ENV['DATABASE_URL'])
+
+    @conn = PG::Connection.new(
+      user: uri.user,
+      password: uri.password,
+      host: uri.host,
+      port: uri.port,
+      dbname: uri.path[1..-1],
+    )
+  end
+
+  def self.migrate
+    ensure_migrations_table
+
+    migrations = Dir[File.join(Laris::ROOT, "/db/migrations/*.sql")]
+    migrations.each do |file|
+      filename = file.match(/([\w|-]*)\.sql$/)[1]
+
+      unless migrated_files.include?(filename)
+        instance.exec(File.read(file))
+        instance.exec(<<-SQL)
+          INSERT INTO
+            migrations (filename)
+          VALUES
+            ('#{filename}')
+          SQL
+      end
+    end
+  end
+
+  def self.execute(query, params=[])
+    query = number_placeholders(query)
+    print_query(query, params)
+    res = instance.exec(query, params)
+  end
+
+  def self.columns(table_name)
+    cols = instance.exec(<<-SQL)
+      SELECT
+        attname
+      FROM
+        pg_attribute
+      WHERE
+        attrelid = '#{table_name}'::regclass AND
+        attnum > 0 AND
+        NOT attisdropped
+    SQL
+
+    cols.map { |col| col['attname'].to_sym }
+  end
+
+  private
+
+  def self.ensure_migrations_table
+    res = instance.exec(<<-SQL)
+      SELECT to_regclass('migrations') AS exists
+    SQL
+
+    unless res[0]['exists']
+      instance.exec(<<-SQL)
+        CREATE TABLE migrations (
+          id SERIAL PRIMARY KEY,
+          filename VARCHAR(255) NOT NULL
+        )
+      SQL
+    end
+  end
+
+  def self.instance
+    open if @conn.nil?
+    @conn
+  end
+
+  def self.migrated_files
+    Set.new instance.exec(<<-SQL).values.flatten
+      SELECT
+        filename
+      FROM
+        migrations
+    SQL
+  end
+
+  def self.number_placeholders(query_string)
+    count = 0
+    query_string.chars.map do |char|
+      if char == "?"
+        count += 1
+        "$#{count}"
+      else
+        char
+      end
+    end.join("")
+  end
+
+  def self.print_query(query, interpolation_args)
+    puts '--------------------'
+    puts query
+    unless interpolation_args.empty?
+      puts "interpolate: #{interpolation_args.inspect}"
+    end
+    puts '--------------------'
+  end
+end

data/lib/laris/larisrecord/larisrecord_base.rb

@@ -0,0 +1,113 @@
+class LarisrecordBase
+  def self.columns
+    return @columns if @columns
+
+    @columns = DBConnection.columns(table_name)
+  end
+
+  def self.destroy_all
+    all.each { |row| row.destroy }
+  end
+
+  def self.destroy(row)
+    row = find(row) if row.is_a?(Integer)
+    row.destroy
+  end
+
+  def self.laris_finalize!
+    columns.each do |attr_name|
+      define_method(attr_name) do
+        attributes[attr_name]
+      end
+
+      define_method("#{attr_name}=") do |value|
+        attributes[attr_name] = value
+      end
+    end
+  end
+
+  def self.table_name=(table_name)
+    @table_name = table_name
+  end
+
+  def self.table_name
+    @table_name ||= self.to_s.tableize
+  end
+
+  def initialize(params = {})
+    params.each do |attr_name, value|
+      if self.class.columns.include?(attr_name.to_sym)
+        send("#{attr_name}=", value)
+      else
+        raise "unknown attribute '#{attr_name}'"
+      end
+    end
+  end
+
+  def attributes
+    @attributes ||= {}
+  end
+
+  def attribute_values
+    columns.map { |attr_name| send(attr_name) }
+  end
+
+  def destroy
+    DBConnection.execute(<<-SQL, [id])
+      DELETE FROM
+        #{table_name}
+      WHERE
+        #{table_name}.id = ?
+    SQL
+
+    self
+  end
+
+  def insert
+    cols = columns.reject { |col| col == :id }
+    col_values = cols.map { |attr_name| send(attr_name) }
+    col_names = cols.join(", ")
+    question_marks = (["?"] * cols.size).join(", ")
+
+    result = DBConnection.execute(<<-SQL, col_values)
+      INSERT INTO
+        #{table_name} (#{col_names})
+      VALUES
+        (#{question_marks})
+      RETURNING id
+    SQL
+
+    self.id = result.first['id']
+    # DBConnection.last_insert_row_id
+
+    true
+  end
+
+  def save
+    id ? update : insert
+  end
+
+  def update
+    set_sql = columns.map { |attr_name| "#{attr_name} = ?" }.join(", ")
+
+    result = DBConnection.execute(<<-SQL, attribute_values << id)
+      UPDATE
+        #{table_name}
+      SET
+        #{set_sql}
+      WHERE
+        #{table_name}.id = ?
+    SQL
+
+    true
+  end
+
+  private
+  def columns
+    self.class.columns
+  end
+
+  def table_name
+    self.class.table_name
+  end
+end

data/lib/laris/larisrecord/relation.rb

@@ -0,0 +1,85 @@
+class Relation
+    SQL_COMMANDS = {
+      select: 'SELECT',
+      from: 'FROM',
+      joins: 'JOIN',
+      where: 'WHERE',
+      order: 'ORDER BY',
+      limit: 'LIMIT'
+    }
+
+    attr_reader :klass, :sql_clauses
+    attr_accessor :cache, :values
+
+    def initialize(klass, values = [], sql_clauses = {})
+      @klass = klass
+      @values = values
+      @sql_clauses = sql_defaults.merge(sql_clauses)
+      @cache = nil
+    end
+
+    def method_missing(method, *args, &blk)
+      query if cache.nil?
+      cache.send(method, *args, &blk)
+    end
+
+    def reload!
+      query
+    end
+
+    def order(column, direction = 'ASC')
+      sql_clauses[:order] = "#{table_name}.#{column} #{direction}"
+      self
+    end
+
+    # allows only a single join
+    def joins(table, on = nil)
+      condition = "#{table} ON #{on}"
+
+      sql_clauses[:joins] =
+        [sql_clauses[:joins], condition].compact.join(' JOIN ')
+
+      self
+    end
+
+    def limit(n)
+      sql_clauses[:limit] = n
+      self
+    end
+
+    def where(conditions)
+      new_fragments = conditions.map do |attr_name, value|
+        values << value
+        "#{table_name}.#{attr_name} = ?"
+      end
+
+      where_fragments = new_fragments.unshift(sql_clauses[:where])
+      sql_clauses[:where] = where_fragments.compact.join(" AND ")
+
+      self
+    end
+
+    private
+    def query
+      results = DBConnection.execute(statement, values)
+      self.cache = klass.parse_all(results)
+    end
+
+    def sql_defaults
+      {
+        select: "#{table_name}.*",
+        from: "#{table_name}"
+      }
+    end
+
+    def statement
+      clauses = SQL_COMMANDS.map do |keyword, command|
+        "#{command} #{sql_clauses[keyword]}" if sql_clauses[keyword]
+      end
+      clauses.compact.join(" ")
+    end
+
+    def table_name
+      klass.table_name
+    end
+end

data/lib/laris/larisrecord/searchable.rb

@@ -0,0 +1,43 @@
+module Searchable
+  def all
+    Relation.new(self)
+  end
+
+  def find(id)
+    all.where(id: id).limit(1).first
+  end
+
+  def find_by(conditions)
+    all.where(conditions).limit(1).first
+  end
+
+  def find_by_sql(sql, values = [])
+    results = DBConnection.execute(sql, values)
+    parse_all(results)
+  end
+
+  def first
+    all.order(:id).limit(1).first
+  end
+
+  def last
+    all.order(:id, :DESC).limit(1).first
+  end
+
+  def method_missing(method_name, *args)
+    if method_name.to_s.start_with?("find_by_")
+      columns = method_name[8..-1].split('_and_')
+
+      conditions = {}
+      columns.size.times { |i| conditions[columns[i]] = args[i] }
+
+      all.where(conditions).limit(1).first
+    else
+      all.send(method_name, *args)
+    end
+  end
+
+  def parse_all(results)
+    results.map { |params| new(params) }
+  end
+end

data/lib/laris/router.rb

@@ -0,0 +1,61 @@
+class Route
+  attr_reader :pattern, :http_method, :controller_class, :action_name
+
+  def initialize(pattern, http_method, controller_class, action_name)
+    @pattern, @http_method, @controller_class, @action_name =
+      pattern, http_method, controller_class, action_name
+  end
+
+  def matches?(req)
+    pattern =~ req.path &&
+      http_method == req.request_method.downcase.to_sym
+  end
+
+  def run(req, res)
+    match_data = pattern.match(req.path)
+    route_params = Hash[match_data.names.zip(match_data.captures)]
+
+    controller = controller_class.new(req, res, route_params)
+    controller.invoke_action(action_name, http_method)
+  end
+end
+
+class Router
+  attr_reader :routes
+
+  def initialize
+    @routes = []
+  end
+
+  def add_route(pattern, http_method, controller_class, action_name)
+    @routes << Route.new(pattern, http_method, controller_class, action_name)
+  end
+
+  def draw(&proc)
+    instance_eval(&proc)
+  end
+
+  [:get, :post, :patch, :delete].each do |http_method|
+    define_method(http_method) do |pattern, controller_class, action_name|
+      add_route(pattern, http_method, controller_class, action_name)
+    end
+  end
+
+  def match(req)
+    @routes.find { |route| route.matches?(req) }
+  end
+
+  def run(req, res)
+    route = match(req)
+
+    if route.nil?
+      res.status = 404
+
+      res.write("Oops! The requested URL #{req.path} was not not found!")
+    else
+      route.run(req, res)
+    end
+  end
+end
+
+Laris::Router = Router.new

metadata

@@ -0,0 +1,132 @@
+--- !ruby/object:Gem::Specification
+name: laris
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Daniel Colson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-01-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Laris is a rails-inspired web application framework.
+email:
+- danieljamescolson@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/laris.rb
+- lib/laris/asset_server.rb
+- lib/laris/autoloader.rb
+- lib/laris/controller.rb
+- lib/laris/controller/controller_base.rb
+- lib/laris/controller/csrf.rb
+- lib/laris/controller/flash.rb
+- lib/laris/controller/session.rb
+- lib/laris/exception_view.html.erb
+- lib/laris/exception_viewer.rb
+- lib/laris/larisrecord.rb
+- lib/laris/larisrecord/associatable.rb
+- lib/laris/larisrecord/db_connection.rb
+- lib/laris/larisrecord/larisrecord_base.rb
+- lib/laris/larisrecord/relation.rb
+- lib/laris/larisrecord/searchable.rb
+- lib/laris/router.rb
+homepage: https://github.com/composerinteralia/laris
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Lightweight MVC framework
+test_files: []