raamen 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8a824183af8e3398198698e5005affd11902c660
-  data.tar.gz: a6fa9471d103bdfff64c07b2ba44f655fbf40f40
+  metadata.gz: 31023fc5e442be1d7d1f7346a40bb53355847fcb
+  data.tar.gz: f4fe204f88692a72324501ab003627b4c37b43af
 SHA512:
-  metadata.gz: 26905102435808cb9c096506578f6ce226ae56f891154d90ebd007f62870a0a88460973e5f9edb9d5287511fea3a8538ab5297642299254871d840a14dc65703
-  data.tar.gz: abfaaa5d58acb5524711a44794bdb403acfbb15485670e74ad94d3ed1e223df05aee054881e5cdbb979c8569ec63e1b8efafdcc915623494694b138d28e1f779
+  metadata.gz: 3b37d65b71beafcab9e9ce8e25c8b10a0f1523c7ba2441c44d2a0354a105866ba20627ec5adf918c1a592dd04c3b62bbe8a40df8d3daa85e90747dc1c685356f
+  data.tar.gz: 03b2e0b4b29254475fd02eeceee34237296fc71cad2a6af1cbc0bfaa7252d7af1aabc68b624d7d3bae7577b87d59eebca337295d6d9ef536e9c6075823a1a5d7

data/lib/raamen.rb

@@ -1,4 +1,9 @@
-require "raamen/version"
+require_relative "raamen/version.rb"
+require_relative "raamen/sql_object"
+require_relative "raamen/controller_base"
+require_relative "raamen/router"
+require_relative "raamen/static"
+require_relative "raamen/show_exceptions"
 
 module Raamen
   # Your code goes here...

data/lib/raamen/controller_base.rb

@@ -0,0 +1,90 @@
+require 'active_support'
+require 'active_support/core_ext'
+require 'erb'
+require_relative 'session'
+require_relative 'flash'
+
+module Raamen
+  class ControllerBase
+    attr_reader :req, :res, :params, :session, :flash
+    attr_accessor :already_built_response, :authenticity_token
+
+    def initialize(req, res, route_params = {})
+      @req = req
+      @res = res
+      @params = route_params.merge(req.params)
+      @session = Session.new(req)
+      @flash = Flash.new(req)
+      @already_built_response = false
+      @authenticity_token = generate_authenticity_token
+      @@protect_from_forgery ||= false
+    end
+
+    def already_built_response?
+      self.already_built_response
+    end
+
+    def redirect_to(url)
+      raise "double render" if already_built_response?
+      self.res["location"] = url
+      self.res.status = 302
+      self.session.store_session(res)
+      self.flash.store_flash(res)
+      self.already_built_response = true
+    end
+
+    def render_content(content, content_type)
+      raise "double render" if already_built_response?
+      self.res["Content-Type"] = content_type
+      self.res.write(content)
+      self.session.store_session(res)
+      self.flash.store_flash(res)
+      self.already_built_response = true
+    end
+
+    def render(template_name)
+      template_path = File.join(
+        File.dirname(__FILE__),
+        "..",
+        "views",
+        "#{self.class.name.underscore}",
+        "#{template_name}.html.erb"
+        )
+      template_content = File.read(template_path)
+      render_content(ERB.new(template_content).result(binding), "text/html")
+    end
+
+    def invoke_action(name)
+      if @@protect_from_forgery && self.req.request_method != "GET"
+        check_authenticity_token
+      end
+      self.send(name)
+      render(name) unless already_built_response?
+    end
+
+    def form_authenticity_token
+      self.res.set_cookie(
+        "authenticity_token",
+        {path: "/", value: self.authenticity_token}
+      )
+      self.authenticity_token
+    end
+
+    def self.protect_from_forgery
+      @@protect_from_forgery = true
+    end
+
+    private
+
+    def generate_authenticity_token
+      SecureRandom.urlsafe_base64(16)
+    end
+
+    def check_authenticity_token
+      cookie = self.req.cookies["authenticity_token"]
+      unless cookie && cookie == params["authenticity_token"]
+        raise "Invalid authenticity token"
+      end
+    end
+  end
+end

data/lib/raamen/db/sqlite3.sql

@@ -0,0 +1,43 @@
+CREATE TABLE cats (
+  id INTEGER PRIMARY KEY,
+  name VARCHAR(255) NOT NULL,
+  owner_id INTEGER,
+
+  FOREIGN KEY(owner_id) REFERENCES human(id)
+);
+
+CREATE TABLE humans (
+  id INTEGER PRIMARY KEY,
+  fname VARCHAR(255) NOT NULL,
+  lname VARCHAR(255) NOT NULL,
+  house_id INTEGER,
+
+  FOREIGN KEY(house_id) REFERENCES human(id)
+);
+
+CREATE TABLE houses (
+  id INTEGER PRIMARY KEY,
+  address VARCHAR(255) NOT NULL
+);
+
+INSERT INTO
+  houses (id, address)
+VALUES
+  (1, "26th and Guerrero"), (2, "Dolores and Market");
+
+INSERT INTO
+  humans (id, fname, lname, house_id)
+VALUES
+  (1, "Devon", "Watts", 1),
+  (2, "Matt", "Rubens", 1),
+  (3, "Ned", "Ruggeri", 2),
+  (4, "Catless", "Human", NULL);
+
+INSERT INTO
+  cats (id, name, owner_id)
+VALUES
+  (1, "Breakfast", 1),
+  (2, "Earl", 2),
+  (3, "Haskell", 3),
+  (4, "Markov", 3),
+  (5, "Stray Cat", NULL);

data/lib/raamen/db_connection.rb

@@ -0,0 +1,62 @@
+require 'sqlite3'
+
+module Raamen
+  PRINT_QUERIES = ENV['PRINT_QUERIES'] == 'true'
+  # https://tomafro.net/2010/01/tip-relative-paths-with-file-expand-path
+  ROOT_FOLDER = File.join(File.dirname(__FILE__), '..')
+  SQL_FILE = File.join(ROOT_FOLDER, 'db', 'sqlite3.sql')
+  DB_FILE = File.join(ROOT_FOLDER, 'db', 'sqlite3.db')
+
+  class DBConnection
+    def self.open(db_file_name)
+      @db = SQLite3::Database.new(db_file_name)
+      @db.results_as_hash = true
+      @db.type_translation = true
+
+      @db
+    end
+
+    def self.reset
+      commands = [
+        "rm '#{DB_FILE}'",
+        "cat '#{SQL_FILE}' | sqlite3 '#{DB_FILE}'"
+      ]
+
+      commands.each { |command| `#{command}` }
+      DBConnection.open(DB_FILE)
+    end
+
+    def self.instance
+      reset if @db.nil?
+
+      @db
+    end
+
+    def self.execute(*args)
+      print_query(*args)
+      instance.execute(*args)
+    end
+
+    def self.execute2(*args)
+      print_query(*args)
+      instance.execute2(*args)
+    end
+
+    def self.last_insert_row_id
+      instance.last_insert_row_id
+    end
+
+    private
+
+    def self.print_query(query, *interpolation_args)
+      return unless PRINT_QUERIES
+
+      puts '--------------------'
+      puts query
+      unless interpolation_args.empty?
+        puts "interpolate: #{interpolation_args.inspect}"
+      end
+      puts '--------------------'
+    end
+  end
+end

data/lib/raamen/flash.rb

@@ -0,0 +1,41 @@
+require 'json'
+
+module Raamen
+  class Flash
+    attr_reader :flash, :now
+
+    def initialize(req)
+      flash = req.cookies["_rails_lite_app_flash"]
+      @now = flash ? Now.new(JSON.parse(flash)) : Now.new({})
+      @flash = {}
+    end
+
+    def [](key)
+      self.now[key.to_sym] || self.flash[key.to_sym]
+    end
+
+    def []=(key, val)
+      self.flash[key.to_sym] = val
+    end
+
+    def store_flash(res)
+      res.set_cookie("_rails_lite_app_flash", {path: "/", value: self.flash.to_json})
+    end
+  end
+
+  class Now
+    attr_reader :now
+
+    def initialize(now)
+      @now = Hash[now.map{ |k,v| [k.to_sym, v] }]
+    end
+
+    def [](key)
+      self.now[key.to_sym]
+    end
+
+    def []=(key, val)
+      self.now[key.to_sym] = val
+    end
+  end
+end

data/lib/raamen/router.rb

@@ -0,0 +1,62 @@
+module Raamen
+  class Route
+    attr_reader :pattern, :http_method, :controller_class, :action_name
+
+    def initialize(pattern, http_method, controller_class, action_name)
+      @pattern = pattern
+      @http_method = http_method
+      @controller_class = controller_class
+      @action_name = action_name
+    end
+
+    def matches?(req)
+      req.path =~ self.pattern &&
+      req.request_method == self.http_method.to_s.upcase
+    end
+
+    def run(req, res)
+      match_data = self.pattern.match(req.path)
+      route_params = Hash[match_data.names.zip(match_data.captures)]
+      self.controller_class.new(req, res, route_params)
+        .invoke_action(self.action_name)
+    end
+  end
+
+  class Router
+    attr_reader :routes
+
+    def initialize
+      @routes = []
+    end
+
+    def add_route(pattern, method, controller_class, action_name)
+      self.routes.push(Route.new(pattern, method, controller_class, action_name))
+    end
+
+    def draw(&proc)
+      self.instance_eval(&proc)
+    end
+
+    [:get, :post, :put, :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)
+      self.routes.each do |route|
+        return route if route.matches?(req)
+      end
+      nil
+    end
+
+    def run(req, res)
+      matching_route = match(req)
+      unless matching_route
+        res.status = 404
+        return
+      end
+      matching_route.run(req, res)
+    end
+  end
+end

data/lib/raamen/session.rb

@@ -0,0 +1,25 @@
+require 'json'
+
+module Raamen
+  class Session
+    attr_reader :cookies
+
+    def initialize(req)
+      cookies = req.cookies["_rails_lite_app"]
+      cookies = Hash[JSON.parse(cookies).map{ |k,v| [k.to_sym, v] }] if cookies
+      @cookies = cookies || {}
+    end
+
+    def [](key)
+      self.cookies[key.to_sym]
+    end
+
+    def []=(key, val)
+      self.cookies[key.to_sym] = val
+    end
+
+    def store_session(res)
+      res.set_cookie("_rails_lite_app", {path: "/", value: self.cookies.to_json})
+    end
+  end
+end

data/lib/raamen/show_exceptions.rb

@@ -0,0 +1,66 @@
+require 'erb'
+
+module Raamen
+  class ShowExceptions
+    attr_reader :app
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      begin
+        self.app.call(env)
+      rescue Exception => e
+        render_exception(e)
+      end
+    end
+
+    private
+
+    def render_exception(e)
+      template_path = File.join(
+        File.dirname(__FILE__),
+        "templates",
+        "rescue.html.erb")
+      template_content = File.read(template_path)
+      content = ERB.new(template_content).result(binding)
+
+      res = Rack::Response.new
+      res.status = 500
+      res["Content-Type"] = "text/html"
+      res.write(content)
+      res.finish
+    end
+
+    def stack_trace_top(e)
+      e.backtrace[0].split(':')
+    end
+
+    def source_line_num(e)
+      stack_trace_top(e)[1].to_i
+    end
+
+    def error_source_file(e)
+      stack_trace_top(e)[0]
+    end
+
+    def extract_source(file)
+      source_file = File.open(file, 'r')
+      source_file.readlines
+    end
+
+    def format_source(source_lines, source_line_num)
+      start = [0, source_line_num - 3].max
+      lines = source_lines[start..(start + 5)]
+      Hash[*(start + 1..(lines.count + start)).zip(lines).flatten]
+    end
+
+    def extract_formatted_source(e)
+      source_file_name = error_source_file(e)
+      source_line_num = source_line_num(e)
+      source_lines = extract_source(source_file_name)
+      format_source(source_lines, source_line_num)
+    end
+  end
+end

data/lib/raamen/sql_object.rb

@@ -0,0 +1,120 @@
+require_relative 'db_connection'
+require_relative 'sql_object_modules/searchable'
+require_relative 'sql_object_modules/associatable'
+require 'active_support/inflector'
+
+module Raamen
+  class SQLObject
+    extend Searchable
+    extend Associatable
+
+    def self.columns
+      @columns ||= DBConnection.execute2(<<-SQL).first.map(&:to_sym)
+        SELECT
+          *
+        FROM
+          #{self.table_name}
+        LIMIT
+          0
+      SQL
+    end
+
+    def self.finalize!
+      self.columns.each do |col|
+        define_method(col) do
+          attributes[col]
+        end
+
+        define_method("#{col}=") do |value|
+          attributes[col] = value
+        end
+      end
+    end
+
+    def self.table_name=(table_name)
+      @table_name = table_name
+    end
+
+    def self.table_name
+      @table_name || self.name.tableize
+    end
+
+    def self.all
+      parse_all(results = DBConnection.execute(<<-SQL))
+        SELECT
+          *
+        FROM
+          #{self.table_name}
+      SQL
+    end
+
+    def self.parse_all(results)
+      results.map do |result|
+        self.new(result)
+      end
+    end
+
+    def self.find(id)
+      parse_all(DBConnection.execute(<<-SQL, id)).first
+        SELECT
+          *
+        FROM
+          #{self.table_name}
+        WHERE
+          id = ?
+      SQL
+    end
+
+    def initialize(params = {})
+      params.each do |col, value|
+        col = col.to_sym
+        raise "unknown attribute '#{col}'" unless self.class.columns.include?(col)
+        self.send("#{col}=", value)
+      end
+    end
+
+    def attributes
+      @attributes ||= {}
+    end
+
+    def attribute_values
+      self.class.columns.map do |col|
+        self.send(col)
+      end
+    end
+
+    def insert
+      columns = self.class.columns.drop(1)
+      col_names = columns.map(&:to_sym).join(", ")
+      question_marks = (["?"] * columns.count).join(", ")
+
+      DBConnection.execute(<<-SQL, attribute_values.drop(1))
+        INSERT INTO
+          #{self.class.table_name} (#{col_names})
+        VALUES
+          (#{question_marks})
+      SQL
+
+      self.id = DBConnection.last_insert_row_id
+    end
+
+    def update
+      set_line = self.class.columns.map do |col|
+        "#{col}= ?"
+      end.join(", ")
+
+      DBConnection.execute(<<-SQL, *attribute_values, id)
+        UPDATE
+          #{self.class.table_name}
+        SET
+          #{set_line}
+        WHERE
+          id = ?
+      SQL
+    end
+
+    def save
+      id.nil? ? insert : update
+    end
+  end
+end

data/lib/raamen/sql_object_modules/associatable.rb

@@ -0,0 +1,90 @@
+module Raamen
+  class AssocOptions
+    attr_accessor(
+      :foreign_key,
+      :class_name,
+      :primary_key
+    )
+
+    def model_class
+      self.class_name.constantize
+    end
+
+    def table_name
+      model_class.table_name
+    end
+  end
+
+  class BelongsToOptions < AssocOptions
+    def initialize(name, options = {})
+      self.class_name = options[:class_name] || name.to_s.camelcase
+      self.foreign_key = options[:foreign_key] || (name.to_s +  "_id").to_sym
+      self.primary_key = options[:primary_key] || :id
+    end
+  end
+
+  class HasManyOptions < AssocOptions
+    def initialize(name, self_class_name, options = {})
+      self.class_name = options[:class_name] || name.to_s.singularize.camelcase
+      self.foreign_key = options[:foreign_key] || (self_class_name.downcase + "_id").to_sym
+      self.primary_key = options[:primary_key] || :id
+    end
+  end
+
+  module Associatable
+    def belongs_to(name, options = {})
+      self.assoc_options[name] = BelongsToOptions.new(name, options)
+
+      define_method(name) do
+        options = self.class.assoc_options[name]
+        key_val = self.send(options.foreign_key)
+        options.model_class.where(options.primary_key => key_val).first
+      end
+    end
+
+    def has_many(name, options = {})
+      self.assoc_options[name] = HasManyOptions.new(name, self.name, options)
+
+      define_method(name) do
+        options = self.class.assoc_options[name]
+        key_val = self.send(options.primary_key)
+        options.model_class.where(options.foreign_key => key_val)
+      end
+    end
+
+    def has_one_through(name, through_name, source_name)
+      define_method(name) do
+        through_options = self.class.assoc_options[through_name]
+        source_options = through_options.model_class.assoc_options[source_name]
+
+        through_table = through_options.table_name
+        through_pk = through_options.primary_key
+        through_fk = through_options.foreign_key
+
+        source_table = source_options.table_name
+        source_pk = source_options.primary_key
+        source_fk = source_options.foreign_key
+
+        key_val = self.send(through_fk)
+        results = DBConnection.execute(<<-SQL, key_val)
+          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_options.model_class.parse_all(results).first
+      end
+    end
+
+    def assoc_options
+      @assoc_options ||= {}
+    end
+  end
+end

data/lib/raamen/sql_object_modules/searchable.rb

@@ -0,0 +1,18 @@
+module Raamen
+  module Searchable
+    def where(params)
+      where_line = params.keys.map do |col|
+        "#{col}= ?"
+      end.join(" AND ")
+
+      parse_all(DBConnection.execute(<<-SQL, *params.values))
+        SELECT
+          *
+        FROM
+          #{self.table_name}
+        where
+          #{where_line}
+      SQL
+    end
+  end
+end

data/lib/raamen/static.rb

@@ -0,0 +1,59 @@
+module Raamen
+  class Static
+    attr_reader :app, :root, :file_server
+
+    def initialize(app)
+      @app = app
+      @root = :public
+      @file_server = FileServer.new(self.root)
+    end
+
+    def call(env)
+      req = Rack::Request.new(env)
+      path = req.path
+
+      if path.include?("/#{self.root}")
+        res = self.file_server.call(env)
+      else
+        res = self.app.call(env)
+      end
+
+      res
+    end
+  end
+
+  class FileServer
+    MIME_TYPES = {
+      ".txt" => "text/plain",
+      ".jpg" => "image/jpeg",
+      ".zip" => "application/zip"
+    }
+
+    def initialize(root)
+      @root = root
+    end
+
+    def call(env)
+      req = Rack::Request.new(env)
+      res = Rack::Response.new
+      file_path = File.join(
+        File.dirname(__FILE__),
+        "..",
+        req.path
+      )
+
+      if File.exist?(file_path)
+        extension = File.extname(file_path)
+        content_type = MIME_TYPES[extension]
+        file_content = File.read(file_path)
+        res["Content-Type"] = content_type
+        res.write(file_content)
+      else
+        res.status = 404
+        res.write("File not found")
+      end
+
+      res
+    end
+  end
+end

data/lib/raamen/templates/rescue.html.erb

@@ -0,0 +1,52 @@
+<head>
+  <style>
+    .header {
+      color: red;
+    }
+
+    .source-view {
+      border: 10px solid lightgray;
+      width: 800px;
+    }
+
+    .line {
+      white-space: pre-wrap;
+    }
+
+    .line-num {
+    }
+
+    .line.error {
+      color: red;
+    }
+  </style>
+</head>
+
+<body>
+  <h2 class='header'><%=e.class%>: <%=e.message%></h2>
+
+  <h4>Extracted source (around line <b><%=source_line_num(e)%></b>):</h4>
+
+  <div class='source-view'>
+    <table cellpadding="0" cellspacing="0">
+      <% extract_formatted_source(e).each do |line_num, line| %>
+        <tr>
+          <td>
+            <pre class='line-num'> <%=line_num %> </pre>
+          </td>
+          <td>
+            <pre class='line
+              <%= 'error' if line_num == source_line_num(e)%>'><%= line %></pre>
+          </td>
+        </tr>
+      <% end %>
+    </table>
+  </div>
+  <h5><%= File.expand_path(error_source_file(e)) %></h5>
+
+  <h3>Stack trace</h3>
+  <% e.backtrace.each do |stack_line| %>
+    <%= stack_line %>
+    <br>
+  <% end %>
+</body>

data/lib/raamen/version.rb

@@ -1,3 +1,3 @@
 module Raamen
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: raamen
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Yuan Gao
@@ -70,6 +70,19 @@ files:
 - bin/console
 - bin/setup
 - lib/raamen.rb
+- lib/raamen/controller_base.rb
+- lib/raamen/db/sqlite3.db
+- lib/raamen/db/sqlite3.sql
+- lib/raamen/db_connection.rb
+- lib/raamen/flash.rb
+- lib/raamen/router.rb
+- lib/raamen/session.rb
+- lib/raamen/show_exceptions.rb
+- lib/raamen/sql_object.rb
+- lib/raamen/sql_object_modules/associatable.rb
+- lib/raamen/sql_object_modules/searchable.rb
+- lib/raamen/static.rb
+- lib/raamen/templates/rescue.html.erb
 - lib/raamen/version.rb
 - raamen.gemspec
 homepage: https://github.com/yuangaonyc/raamen