tgauge 0.1.0

data/lib/app/models/trecord_base.rb

@@ -0,0 +1,163 @@
+require 'active_support/inflector'
+require_relative 'searchable'
+require_relative 'associatable'
+require_relative '../../db/db_connection'
+
+module TGauge
+  class TRecordBase
+    extend Associatable
+    extend Searchable
+
+    def self.my_attr_accessor(*names)
+      names.each do |name|
+        define_method(name) do
+          instance_variable_get("@" + name.to_s)
+        end
+
+        define_method(name.to_s + "=") do |arg|
+          instance_variable_set("@" + name.to_s, arg)
+        end
+      end
+    end
+
+    def self.my_attr_reader(*names)
+      names.each do |name|
+        define_method(name) do
+          instance_variable_get("@" + name.to_s)
+        end
+      end
+    end
+
+    def self.columns
+      # ...
+      return @columns if @columns
+
+      arr = DBConnection.execute(<<-SQL)
+      SELECT
+      *
+      FROM
+      #{self.table_name}
+      SQL
+
+      @columns = []
+      arr.nfields.times do |i|
+        @columns << arr.fname(i)
+      end
+
+      @columns
+    end
+
+    def self.finalize!
+      columns.each do |column|
+        inst_var = "@" + column.to_s
+        define_method(column) do
+          attributes[column]
+        end
+        define_method(column.to_s + "=") do |arg|
+          attributes[column] = arg
+        end
+      end
+    end
+
+    def self.table_name=(table_name)
+      @table_name = table_name
+    end
+
+    def self.table_name
+      @table_name = @table_name || self.to_s.tableize
+    end
+
+    def self.all
+      objs_arr = DBConnection.execute(<<-SQL)
+      SELECT
+      #{table_name}.*
+      FROM
+      #{table_name}
+      SQL
+
+      parse_all(objs_arr)
+    end
+
+    def self.parse_all(results)
+      # ...
+      results.map { |obj_hash| self.new(obj_hash) }
+    end
+
+    def self.find(id)
+      obj = DBConnection.execute(<<-SQL, id)
+      SELECT
+      #{table_name}.*
+      FROM
+      #{table_name}
+      WHERE
+      #{table_name}.id = ?
+      SQL
+
+      parse_all(obj).first
+    end
+
+    def initialize(params = {})
+      # ...
+      params.each do |att_name, val|
+        att_name = att_name.to_sym
+        raise "unknown attribute '#{att_name}'" unless columns.include?(att_name.to_s)
+        self.send(att_name.to_s + "=", val)
+      end
+    end
+
+    def attributes
+      @attributes ||= {}
+    end
+
+    def attribute_values
+      attributes.values
+    end
+
+    def insert
+      cols = columns.reject { |col| col == "id" }
+      attr_count = cols.count
+      column_str = cols.join(", ")
+      quest_str = Array.new(attr_count) {"?"}.join(", ")
+      debugger
+      DBConnection.execute(<<-SQL, attribute_values)
+      INSERT INTO
+      #{table_name} (#{column_str})
+      VALUES
+      (#{quest_str})
+      SQL
+    end
+
+    def update
+      attr_count = columns.count - 1
+      column_str = columns[1..-1].map { |col| "#{col} = ?" }.join(", ")
+
+      DBConnection.execute(<<-SQL, attribute_values)
+      UPDATE
+      #{table_name}
+      SET
+      #{column_str}
+      WHERE
+      id = ?
+      SQL
+    end
+
+    def save
+      if attributes[:id]
+        update
+      else
+        insert
+      end
+    end
+
+    private
+
+    def columns
+      self.class.columns
+    end
+
+    def table_name
+      self.class.table_name
+    end
+
+  end
+end

data/lib/db/db_connection.rb

@@ -0,0 +1,99 @@
+require 'pg'
+require 'uri'
+require 'yaml'
+
+PRINT_QUERIES = ENV['PRINT_QUERIES'] == 'true'
+MIGRATION_FILES = Dir.glob("./db/migrations/*.sql").to_a
+
+module TGauge
+  class DBConnection
+    def self.app_name
+      YAML.load_file(Dir.pwd + '/config/database.yml')['database']
+    end
+
+    def self.open
+      @postgres = PG::Connection.new(
+        dbname: app_name,
+        port: 5432
+      )
+    end
+
+    def self.migrate
+      ensure_migrations_table
+
+      MIGRATION_FILES.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.instance
+      open if @db.nil?
+
+      @db
+    end
+
+    def self.execute(*args)
+      print_query(*args)
+      instance.execute(*args)
+    end
+
+    def self.last_insert_row_id
+      instance.last_insert_row_id
+    end
+
+    def self.reset
+      commands = [
+        "dropdb #{app_name}",
+        "createdb #{app_name}"
+      ]
+      commands.each { |command| `#{command}` }
+    end
+
+    private
+
+    def self.ensure_migrations_table
+      table = instance.exec(<<-SQL)
+      SELECT to_regclass('migrations') AS exists
+      SQL
+
+      unless table[0]['exists']
+        instance.exec(<<-SQL)
+        CREATE_TABLE migrations(
+        id SERIAL PRIMARY KEY,
+        filename VARCHAR(255) NOT NULL
+        )
+        SQL
+      end
+    end
+
+    def self.migrated_files
+      Set.new instance.exec(<<-SQL).values.flatten
+      SELECT
+      filename
+      FROM
+      migrations
+      SQL
+    end
+
+    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/db/router.rb

@@ -0,0 +1,74 @@
+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
+
+  # checks if pattern matches path and method matches request method
+  def matches?(req)
+    (@pattern =~ req.path) == 0 && req.request_method.downcase == @http_method.to_s
+  end
+
+  # use pattern to pull out route params (save for later?)
+  # instantiate controller and call controller action
+  def run(req, res)
+    match_data = @pattern.match(req.path)
+    route_params = {}
+    match_data.names.each do |key|
+      route_params[key] = match_data[key]
+    end
+
+    controller = controller_class.new(req, res, route_params)
+    controller.invoke_action(@action_name)
+  end
+end
+
+class Router
+  attr_reader :routes
+
+  def initialize
+    @routes = []
+  end
+
+  # simply adds a new route to the list of routes
+  def add_route(pattern, method, controller_class, action_name)
+    @routes << Route.new(pattern, method, controller_class, action_name)
+  end
+
+  # evaluate the proc in the context of the instance
+  # for syntactic sugar :)
+  def draw(&proc)
+    self.instance_eval(&proc)
+  end
+
+  # make each of these methods that
+  # when called add route
+  [:get, :post, :put, :delete].each do |http_method|
+    define_method(http_method) do |path, controller, action_name|
+      add_route(path, http_method, controller, action_name)
+    end
+  end
+
+  # should return the route that matches this request
+  def match(req)
+    @routes.each do |route|
+      return route if route.matches?(req)
+    end
+    nil
+  end
+
+  # either throw 404 or call run on a matched route
+  def run(req, res)
+    route = match(req)
+    if route
+      route.run(req, res)
+    else
+      res.write("Route #{req.path} could not be found.")
+      res.status = 404
+    end
+  end
+end

data/lib/db/server.rb

@@ -0,0 +1,27 @@
+require 'rack'
+require_relative './config/routes'
+require_relative 'lib/static_viewer'
+require_relative 'lib/show_exceptions'
+
+module TGauge
+  class Server
+    def self.start
+      app = Proc.new do |env|
+        req = Rack::Request.new(env)
+        res = Rack::Response.new
+        ROUTER.run(req, res)
+        res.finish
+      end
+
+      full_app = Rack::Builder.new do
+        use ShowExceptions
+        use StaticViewer
+        run app
+      end.to_app
+
+      Rack::Server.start({
+        app: full_app,
+        Port: 3000
+      })
+  end
+end

data/lib/db/show_exceptions.rb

@@ -0,0 +1,62 @@
+require 'erb'
+require 'byebug'
+
+class ShowExceptions
+  attr_reader :app
+
+  def initialize(app)
+    @app = app
+  end
+
+  def call(env)
+    app.call(env)
+  rescue Exception => e
+    render_exception(e)
+  end
+
+  private
+
+  def render_exception(e)
+    dir_path = File.dirname(__FILE__)
+    template_fname = File.join(dir_path, "templates", "error_page.html.erb")
+    template = File.read(template_fname)
+    body = ERB.new(template).result(binding)
+
+    ['500', {'Content-type' => 'text/html'}, [body]]
+  end
+
+  def error_source_file(e)
+    stack_trace_top(e)[0]
+  end
+
+  def stack_trace_top(e)
+    e.backtrace[0].split(':')
+  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
+
+  def source_line_num(e)
+    stack_trace_top(e)[1].to_i
+  end
+
+  def formatted_source(file, source_line_num)
+    source_lines = extract_source(file)
+    format_source(source_lines, source_line_num)
+  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
+end

data/lib/db/static_viewer.rb

@@ -0,0 +1,52 @@
+require 'rack'
+require 'pathname'
+
+class StaticViewer
+  FILE_TYPE = {
+    'jpg' => 'image/jpeg',
+    'zip' => 'application/zip',
+    'png' => 'image/png',
+    'txt' => 'text/plain'
+  }
+
+  def initialize(app)
+    @app = app
+  end
+
+  def call(env)
+    if is_public?(env)
+      req = Rack::Request.new(env)
+      res = Rack::Response.new
+
+      file_path = "#{req.path}"
+      build_response(res, file_path)
+    else
+      @app.call(env)
+    end
+  end
+
+  private
+  def build_response(res, file_path)
+    type = find_content_type(file_path)
+
+    if type && Pathname(file_path).exist?
+      res.write(File.open(file_path, 'r') { |f| (f.read) })
+      res['Content-Type'] = find_content_type(file_path)
+      res.finish
+    else
+      type ? res.write("Could not find file.") : res.write("Unsupported file type")
+      res.status = 404
+      res['Content-Type'] = 'text/html'
+      res.finish
+    end
+  end
+
+  def is_public?(env)
+    !!(Regexp.new("/public/*") =~ env["PATH_INFO"])
+  end
+
+  def find_content_type(path)
+    type = path.match(/\.(\w*)/)[1]
+    FILE_TYPE[type]
+  end
+end

data/lib/db/templates/error_page.html.erb

@@ -0,0 +1,62 @@
+<head>
+  <style>
+    .header {
+      font-family: sans-serif;
+      background: #d00;
+      padding: 10px;
+      color: #fff;
+    }
+
+    .source-view {
+      border: 10px solid lightgray;
+      padding: 5px;
+      width: 800px;
+    }
+
+    .line {
+      white-space: pre-wrap;
+      font-family: sans-serif;
+      padding: 2px 0;
+    }
+
+    .line-num {
+      background: lightgray;
+      padding: 2px;
+      border-top: 1px solid #aaa;
+    }
+
+    .line.error {
+      background: #d00;
+      color: #fff;
+    }
+  </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/templates/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gem "tgauge"

data/lib/templates/config/routes.rb

@@ -0,0 +1,7 @@
+ROUTER = TGauge::Router.new
+
+ROUTER.draw do
+  #ADD ROUTES HERE
+  #EXAMPLE:
+  #get Regexp.new("^/MODEL/"), CONTROLLER, :index
+end

data/lib/templates/db/seeds.rb

@@ -0,0 +1,7 @@
+module TGauge
+  class Seed
+    def self.populate
+      #PUT IN SEEDS HERE
+    end
+  end
+end

data/lib/tgauge.rb

@@ -0,0 +1,16 @@
+module TGauge
+end
+
+require_relative './version.rb'
+
+require_relative './app/models/trecord_base'
+require_relative './app/controllers/tcontroller_base'
+
+Dir.glob('./app/models/*.rb') { |file| require file }
+Dir.glob('./app/controllers/*.rb') { |file| require file }
+
+require './db/seeds'
+
+require_relative './db/db_connection'
+require_relative './db/router'
+require_relative './db/server'

data/lib/version.rb

@@ -0,0 +1,3 @@
+module TGauge
+  VERSION = "0.1.0"
+end