gazebo 0.1.2

data/lib/activeleopard/query_clauses/limit_clause.rb

@@ -0,0 +1,15 @@
+class LimitClause
+  attr_reader :num
+
+  def initialize(num = nil)
+    @num = num
+  end
+
+  def as_sql
+    num.nil? ? "" : "LIMIT #{num} "
+  end
+
+  def set(n)
+    @num = n
+  end
+end

data/lib/activeleopard/query_clauses/order_clause.rb

@@ -0,0 +1,12 @@
+class OrderClause
+  attr_accessor :ordering_attr
+
+  def initialize(ordering_attr = nil)
+    @ordering_attr = ordering_attr
+  end
+
+  def as_sql
+    return "" if ordering_attr.nil?
+    "ORDER BY #{ordering_attr.to_s}"
+  end
+end

data/lib/activeleopard/query_clauses/select_clause.rb

@@ -0,0 +1,18 @@
+class SelectClause
+  attr_accessor :distinct, :params
+
+  def initialize(params = [])
+    @distinct = false
+    @params = params
+  end
+
+  def as_sql
+    "SELECT " +
+    "#{distinct ? 'DISTINCT ' : ''}" +
+    "#{params_as_sql}"
+  end
+
+  def params_as_sql
+    params.map(&:to_s).join(', ')
+  end
+end

data/lib/activeleopard/query_clauses/where_clause.rb

@@ -0,0 +1,61 @@
+require_relative '../errors'
+
+class WhereClause
+  def initialize(options = [])
+    unless options.is_a?(Array) && options.length <= 2
+      raise InvalidInput, "Where takes 1 or 2 arguments"
+    end
+
+    @conditions = parse_conditions(options)
+  end
+
+  def values
+    conditions.values.flatten
+  end
+
+  def as_sql
+    return "" if conditions.empty?
+    " WHERE " + conditions_as_sql
+  end
+
+  def append(options)
+    conditions.merge!(parse_conditions(options))
+  end
+
+  alias_method :<<, :append
+
+  private
+  attr_reader :bind_params, :conditions
+
+  def conditions_as_sql
+    conditions.map do |condition, values|
+      if condition.is_a?(String)
+        format_condition(condition, values)
+      elsif condition.is_a?(Symbol)
+        "#{condition} = ?"
+      end
+    end.flatten.join(' AND ').gsub("?").with_index { |_, i| "$#{i + 1}" }
+  end
+
+  def parse_params(params_input)
+    return [] if params_input.nil?
+    params_input.is_a?(Array) ? params_input : [params_input]
+  end
+
+  def parse_conditions(input)
+    if input.first.is_a?(String)
+      { input.first => parse_params(input[1]) }
+    elsif input.first.is_a?(Hash)
+      input.first
+    else
+      {}
+    end
+  end
+
+  def format_condition(condition, values)
+    condition.gsub('(?)') do
+      "(#{values.map.with_index { |_, i| "$#{i + 1}" }})"
+      # "(#{(['?'] * values.count).join(', ')})"
+    end
+  end
+end

data/lib/activeleopard/relation.rb

@@ -0,0 +1,106 @@
+class Relation
+  include Enumerable
+
+  attr_reader :query, :cache, :source_class, :data
+
+  def defaults
+    {
+      select: SelectClause.new(["#{source_class.table_name}.*"]),
+      from: FromClause.new(source_class.table_name),
+      join: JoinOptions.new,
+      where: WhereClause.new,
+      limit: LimitClause.new,
+      group: GroupClause.new,
+      order: OrderClause.new
+    }
+  end
+
+  def self.ordered_clauses
+    [:select, :from, :join, :where, :group, :order, :limit]
+  end
+
+  def initialize(query, source_class)
+    @source_class = source_class
+    @query = defaults.merge(query)
+    @cache = nil
+  end
+
+  def where(*where_params)
+    query[:where] << where_params
+    empty_cache!
+    self
+  end
+
+  def joins(association, join_class = source_class)
+    options = join_class.assoc_options[association]
+    query[:join].append(options, join_class.table_name)
+    empty_cache!
+    self
+  end
+
+  def limit(n)
+    query[:limit].set(n)
+    empty_cache!
+    self
+  end
+
+  def select(*params)
+    query[:select].params = params
+    empty_cache!
+    self
+  end
+
+  def distinct
+    query[:select].distinct = true
+    empty_cache!
+    self
+  end
+
+  def group(grouping_attr)
+    query[:group].grouping_attr = grouping_attr
+    empty_cache!
+    self
+  end
+
+  def order(ordering_attr)
+    query[:order].ordering_attr = ordering_attr
+    empty_cache!
+    self
+  end
+
+  def as_sql
+    Relation.ordered_clauses.map do |clause|
+      query[clause].as_sql
+    end.join(" \n ")
+  end
+
+  def data
+    execute! if cache.nil?
+    cache
+  end
+
+  def each(&prc)
+    to_a.each { |el| prc.call(el) }
+  end
+
+  def bind_params
+    query[:where].values
+  end
+
+  def to_a
+    execute! if cache.nil?
+    cache.map { |datum| source_class.new(datum) }
+  end
+
+  def execute!
+    @cache = DBConnection.execute(as_sql, bind_params)
+  end
+
+  def inspect
+    p to_a
+  end
+
+  def empty_cache!
+    @cache = nil
+  end
+end

data/lib/activeleopard/sql_object.rb

@@ -0,0 +1,213 @@
+class SQLObject
+  def self.after_initialize(method_name)
+    callbacks[:after_initialize] = method_name
+  end
+
+  def self.all
+    Relation.new({}, self)
+  end
+
+  def self.callbacks
+    @callbacks ||= {}
+  end
+
+  def self.columns
+    return @columns if @columns
+
+    cols = DBConnection.execute(<<-SQL, [self.table_name])
+      SELECT
+        column_name
+      FROM
+        information_schema.columns
+      WHERE
+        table_name = $1
+    SQL
+
+    @columns = cols.map { |c| c['column_name'].to_sym }
+  end
+
+  def self.destroy_all
+    DBConnection.execute(<<-SQL)
+      DELETE FROM #{self.table_name}
+    SQL
+  end
+
+  def self.finalize!
+    self.columns.each do |col|
+      define_method(col) do #setter method
+        attributes[col]
+      end
+
+      define_method("#{col}=") do |val| #getter method
+        attributes[col] = val
+      end
+    end
+  end
+
+  def self.first
+    first_data = DBConnection.get_first_row(<<-SQL)
+    SELECT
+      *
+    FROM
+      #{self.table_name}
+    ORDER BY
+      id
+    LIMIT
+      1
+    SQL
+
+    self.new(first_data)
+  end
+
+  def self.last
+    last_data = DBConnection.get_first_row(<<-SQL)
+    SELECT
+      *
+    FROM
+      #{self.table_name}
+    ORDER BY
+      id DESC
+    LIMIT
+      1
+    SQL
+
+    self.new(last_data)
+  end
+
+  def self.parse_all(all_options)
+    all_options.map { |options| self.new(options) }
+  end
+
+  def self.table_name=(table_name)
+    @table_name = table_name
+  end
+
+  def self.table_name
+    @table_name ||= self.to_s.tableize.gsub('humen') { 'humans' }
+  end
+
+  def self.validations
+    @validations ||= []
+  end
+
+  def attributes
+    @attributes ||= {}
+  end
+
+  def attr_count
+    @attributes.count
+  end
+
+  def attribute_values
+    attributes.values
+  end
+
+  def attr_values_to_update
+    attributes.reject { |attr_name, _| attr_name == :id }.values
+  end
+
+  def col_names
+    self.class.columns
+    .map(&:to_s)
+    .drop(1).join(', ')
+  end
+
+  def destroy
+    DBConnection.execute(<<-SQL, [self.id])
+      DELETE FROM #{self.class.table_name}
+      WHERE id = $1
+    SQL
+  end
+
+  def errors
+    @errors ||= Hash.new { |h, k| h[k] = [] }
+  end
+
+  def initialize(params = {})
+    self.class.columns.each do |attr_name|
+      params_val = params[attr_name] || params[attr_name.to_s]
+      params_val.strip! if params_val
+      send("#{attr_name}=", params_val)
+    end
+
+    params.each do |attr_name, val|
+      attr_method = "#{attr_name}="
+      next if self.class.columns.include?(attr_name.to_sym)
+      next unless self.respond_to?(attr_method)
+
+      val.strip! if val
+      send(attr_method, val)
+    end
+
+    if self.class.callbacks[:after_initialize]
+      send(self.class.callbacks[:after_initialize])
+    end
+  end
+
+  def insert
+    result = DBConnection.execute(<<-SQL, attr_values_to_update)
+    INSERT INTO
+      #{self.class.table_name} (#{col_names})
+    VALUES
+      (#{question_marks})
+    RETURNING
+      id
+    SQL
+
+    self.id = result.getvalue(0,0)
+  end
+
+  def question_marks
+    (1...attributes.count).map { |n| "$#{n}"}.join(', ')
+  end
+
+  def save
+    validate!
+    if valid?
+      id ? update : insert
+      true
+    else
+      show_errors
+      false
+    end
+  end
+
+  def show_errors
+    errors.each do |key, messages|
+      messages.each { |m| puts "#{key} #{m}" }
+    end
+  end
+
+  def to_s
+    "#{self.class}:#{self.object_id}"
+  end
+
+  def update_set_line
+    col_names.split(', ').map.with_index { |c, i| "#{c} = $#{i + 1}" }.join(', ')
+  end
+
+  def update
+    vals = attr_values_to_update << id
+    DBConnection.execute(<<-SQL, vals)
+      UPDATE
+        #{self.class.table_name}
+      SET
+        #{update_set_line}
+      WHERE
+        id = $#{vals.length}
+    SQL
+  end
+
+  def validate!
+    @errors = Hash.new { |h, k| h[k] = [] }
+
+    self.class.validations.each do |validation|
+      self.send(validation)
+    end
+  end
+
+  def valid?
+    validate!
+    errors.all? { |_, v| v.empty? }
+  end
+end

data/lib/auto_loader.rb

@@ -0,0 +1,31 @@
+module Gazebo
+  LOAD_PATHS = [
+    "app/models",
+    "app/controllers"
+  ]
+end
+
+class Object
+  def self.const_missing(const)
+    auto_load(const)
+    Kernel.const_get(const)
+  end
+
+  def auto_load(const)
+    Gazebo::LOAD_PATHS.each do |dir|
+      file = File.join(Gazebo::ROOT, dir, const.to_s.underscore)
+
+      begin
+        require_relative(file)
+        return
+      rescue LoadError => e
+      end
+    end
+  end
+end
+
+class Module
+  def const_missing(const)
+    Object.const_missing(const)
+  end
+end

data/lib/cli.rb

@@ -0,0 +1,16 @@
+require 'thor'
+
+module Gazebo
+  class DatabaseTasks < Thor
+    desc "migrate", "run any previously unexecuted migrations"
+    def migrate
+      DBConnection.run_migrations
+    end
+
+    desc "seed", "seed database"
+    def seed
+      Gazebo.seed
+    end
+  end
+
+end

data/lib/gazebo.rb

@@ -0,0 +1,53 @@
+require 'byebug'
+require 'rack'
+require 'uri'
+
+require_relative 'activeleopard/activeleopard'
+require_relative 'actioncondor/actioncondor'
+require_relative 'static_asset_server'
+require_relative 'show_exceptions'
+require_relative 'auto_loader'
+require_relative 'router'
+require_relative 'cli'
+
+module Gazebo
+  Router = Router.new
+  VERSION = "0.1.2"
+
+  def self.app
+    fetch_routes
+
+    app = Proc.new do |env|
+      req = Rack::Request.new(env)
+      res = Rack::Response.new
+      Gazebo::Router.run(req, res)
+      res
+    end
+
+    app = Rack::Builder.new do
+      use ShowExceptions
+      use StaticAssetServer
+      run app
+    end.to_app
+  end
+
+  def self.root=(root)
+    const_set("ROOT", root)
+  end
+
+  def self.fetch_routes
+    file = File.join(ROOT, "config/routes.rb")
+
+    File.open(file) do |f|
+      self.class_eval(f.read)
+    end
+  end
+
+  def self.seed
+    file = File.join(ROOT, "db/seeds.rb")
+
+    File.open(file) do |f|
+      self.class_eval(f.read)
+    end
+  end
+end

data/lib/router.rb

@@ -0,0 +1,78 @@
+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)
+    return false if (pattern =~ req.path).nil?
+
+    # check if form is providing non-get/post method
+    req_method = req.params["_method"] || req.request_method
+
+    req_method.upcase == http_method.to_s.upcase
+  end
+
+  # use pattern to pull out route params (save for later?)
+  # instantiate controller and call controller action
+  def run(req, res)
+    matched_params = pattern.match(req.path)
+
+    params = {}
+    matched_params.names.each do |param_key|
+      params[param_key] = matched_params[param_key]
+    end
+
+    controller_class.new(req, res, params).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)
+    route = Route.new(pattern, method, controller_class, action_name)
+    @routes << route
+  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 |pattern, controller_class, action_name|
+      add_route(pattern, http_method, controller_class, action_name)
+    end
+  end
+
+  # should return the route that matches this request
+  def match(req)
+    routes.find { |route| route.matches?(req) }
+  end
+
+  # either throw 404 or call run on a matched route
+  def run(req, res)
+    matched_route = match(req)
+
+    if matched_route
+      res.status = 200
+      matched_route.run(req, res)
+    else
+      res.status = 404
+    end
+  end
+end

data/lib/show_exceptions.rb

@@ -0,0 +1,28 @@
+class ShowExceptions
+  attr_reader :app, :error
+
+  def initialize(app)
+    @app = app
+  end
+
+  def call(env)
+    begin
+      @app.call(env)
+    rescue StandardError => e
+      render_exception(e)
+    end
+  end
+
+  private
+
+  def render_exception(e)
+    res = Rack::Response.new
+    file_content = File.read("#{File.dirname(__FILE__)}/templates/rescue.html.erb")
+    content = ERB.new(file_content).result(binding)
+
+    res['Content-Type'] = 'text/html'
+    res.status = 500
+    res.write(content)
+    res.finish
+  end
+end

data/lib/static_asset_server.rb

@@ -0,0 +1,57 @@
+class StaticAssetServer
+  attr_reader :file_server, :app, :root
+
+  def initialize(app)
+    @app = app
+    @root = 'app/assets/'
+    @file_server = FileServer.new
+  end
+
+  def call(env)
+    req = Rack::Request.new(env)
+    path = req.path
+
+    if servable?(path)
+      res = file_server.call(env)
+    else
+      res = app.call(env)
+    end
+    res.finish
+  end
+
+  def servable?(path)
+    path.match("#{root}")
+  end
+end
+
+class FileServer
+  def call(env)
+    res = Rack::Response.new
+    file_name = requested_file_name(env)
+
+    if File.exists?(file_name)
+      serve(file_name, res)
+    else
+      res.status = 404
+      res.write("File not found")
+    end
+    res
+  end
+
+  def serve(file_name, res)
+    extension = File.extname(file_name)
+    extension = '.json' if extension == '.map'
+    content_type = Rack::Mime::MIME_TYPES[extension]
+
+    res['Content-Type'] = content_type
+    file = File.read(file_name)
+    res.write(file)
+  end
+
+  def requested_file_name(env)
+    req = Rack::Request.new(env)
+    path = req.path
+    dir = File.dirname(__FILE__)
+    File.join(dir, '..', path)
+  end
+end

data/lib/templates/rescue.html.erb

@@ -0,0 +1,18 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <title></title>
+  </head>
+  <body>
+    <h1><%= e.class %></h1>
+    <h2>Message: <%= e.message %></h2>
+
+    <h3>Backtrace:</h3>
+    <ul>
+      <% e.backtrace.take(10).each do |trace| %>
+      <li><%= trace %></li>
+      <% end %>
+    </ul>
+  </body>
+</html>