gazebo 0.1.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a7e1c03436e96b489059927089d42de8a98f07ff
+  data.tar.gz: f01dc87cbb489db33f283a2467a5f884992ad235
+SHA512:
+  metadata.gz: 2ac34da08d89d7f35e323af6eda2800c72187d66d8a0207bafe65d73591b771b57549031dd5f6720c2f831cede9fc990ae8442b824d8031082cb6c6f8c373d8c
+  data.tar.gz: 61aff4beade614102cef92417327088d6f7abe458c30caca8e363f539b72851c344e6d9f7beb5de5d84f06cc7210dee1ab053cb2809696183efa6768a6002cae

data/README.md

@@ -0,0 +1,9 @@
+# Gazebo
+
+A light-weight MVC framework inspired by Rails.
+
+## ActiveLeopard
+An ORM with many of the features of Rails ActiveRecord at a fraction of the overhead.
+
+## ActionCondor
+A Controller Base Class that is combined with a custom router and asset server to handle requests and build responses.

data/bin/gazebo

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby -U
+
+require 'gazebo'
+
+Gazebo.root = File.expand_path(Dir.pwd)
+Gazebo::DatabaseTasks.start( ARGV )

data/lib/actioncondor/actioncondor.rb

@@ -0,0 +1,17 @@
+require 'active_support'
+require 'active_support/core_ext'
+require 'active_support/inflector'
+require 'erb'
+require 'byebug'
+require 'rack'
+require 'json'
+
+require_relative 'controller_base'
+require_relative 'flash'
+require_relative 'session'
+
+class ActionCondor
+end
+
+class ActionCondor::Base < ControllerBase
+end

data/lib/actioncondor/controller_base.rb

@@ -0,0 +1,111 @@
+class ControllerBase
+  attr_reader :req, :res, :params, :token, :flash
+
+
+  def self.protect_from_forgery
+    @@protect_from_forgery = true
+  end
+
+  # Setup the controller
+  def initialize(req, res, route_params = {})
+    @req = req
+    @res = res
+    @params = route_params.merge(req.params)
+    @@protect_from_forgery ||= false
+  end
+
+  def flash
+    @flash ||= Flash.new(req)
+  end
+
+  # Helper method to alias @already_built_response
+  def already_built_response?
+    @already_built_response || false
+  end
+
+  # Set the response status code and header
+  def redirect_to(url)
+    check_for_repeat_action!
+    res.status = 302
+    res['location'] = url
+
+    session.store_session(res)
+    flash.store_flash(res)
+    @already_built_response = true
+  end
+
+  # Populate the response with content.
+  # Set the response's content type to the given type.
+  # Raise an error if the developer tries to double render.
+  def render_content(content, content_type)
+    check_for_repeat_action!
+    res['Content-Type'] = content_type
+    res.write(content)
+
+    session.store_session(res)
+    flash.store_flash(res)
+    @already_built_response = true
+  end
+
+  #raise error if already_built_response
+  def check_for_repeat_action!
+    raise "Cannot call render/redirect twice in one action" if already_built_response?
+  end
+
+  # use ERB and binding to evaluate templates
+  # pass the rendered html to render_content
+  def render(template_name)
+    controller_name = self.class.to_s.underscore[0..-("_controller".length + 1)]
+    file_path = "app/views/#{controller_name}/#{template_name}.html.erb"
+    file_content = File.read(file_path)
+
+    application = File.read("app/views/layout/application.html.erb")
+    application.sub!(/__YIELD__/, file_content)
+
+    content = ERB.new(application).result(binding)
+    render_content(content, 'text/html')
+  end
+
+  # method exposing a `Session` object
+  def session
+    @session ||= Session.new(req)
+  end
+
+  # use this with the router to call action_name (:index, :show, :create...)
+  def invoke_action(name)
+    if protect_from_forgery? && req.request_method != 'GET'
+      check_authenticity_token
+    else
+      form_authenticity_token
+    end
+
+    send(name)
+    render(name) unless already_built_response?
+  end
+
+  def protect_from_forgery?
+    @@protect_from_forgery
+  end
+
+  def check_authenticity_token
+    cookie = req.cookies['authenticity_token']
+    unless cookie && cookie == params['authenticity_token']
+      raise "Invalid authenticity token"
+    end
+  end
+
+  def form_authenticity_token
+    @token ||= generate_authenticity_token
+    res.set_cookie(
+      'authenticity_token',
+      path: '/',
+      value: token
+    )
+
+    @token
+  end
+
+  def generate_authenticity_token
+    SecureRandom.urlsafe_base64(16)
+  end
+end

data/lib/actioncondor/flash.rb

@@ -0,0 +1,31 @@
+class Flash
+  def initialize(req)
+    @flash = {}
+
+    app_cookie = req.cookies['_gazebo_app_flash']
+
+    @flash_now = app_cookie ? JSON.parse(app_cookie) : {}
+  end
+
+  def now
+    @flash_now
+  end
+
+  def [](key)
+    @flash[key.to_s] || @flash_now[key.to_s] || @flash_now[key]
+  end
+
+  def []=(key, val)
+    @flash[key.to_s] = val
+  end
+
+  # serialize the hash into json and save in a cookie
+  # add to the responses cookies
+  def store_flash(res)
+    res.set_cookie(
+      '_gazebo_app_flash',
+      path: '/',
+      value: @flash.to_json
+    )
+  end
+end

data/lib/actioncondor/session.rb

@@ -0,0 +1,29 @@
+class Session
+  # find the cookie for this app
+  # deserialize the cookie into a hash
+  attr_reader :cookie
+
+  def initialize(req)
+    app_cookie = req.cookies['_gazebo_app']
+
+    @cookie = app_cookie ? JSON.parse(app_cookie) : {}
+  end
+
+  def [](key)
+    @cookie[key.to_s]
+  end
+
+  def []=(key, val)
+    @cookie[key.to_s] = val
+  end
+
+  # serialize the hash into json and save in a cookie
+  # add to the responses cookies
+  def store_session(res)
+    res.set_cookie(
+      '_gazebo_app',
+      path: '/',
+      value: @cookie.to_json
+    )
+  end
+end

data/lib/activeleopard/activeleopard.rb

@@ -0,0 +1,21 @@
+require 'active_support/inflector'
+require 'colorize'
+
+require_relative 'query_clauses/all_clauses'
+require_relative 'modules/associatable'
+require_relative 'modules/validatable'
+require_relative 'modules/searchable'
+require_relative 'assoc_options'
+require_relative 'db_connection'
+require_relative 'sql_object'
+require_relative 'relation'
+require_relative 'errors'
+
+class ActiveLeopard
+end
+
+class ActiveLeopard::Base < SQLObject
+  extend Associatable
+  extend Searchable
+  extend Validatable
+end

data/lib/activeleopard/assoc_options.rb

@@ -0,0 +1,64 @@
+class AssocOptions
+  attr_accessor(
+    :foreign_key,
+    :class_name,
+    :primary_key
+  )
+
+  def model_class
+    class_name.constantize
+  end
+
+  def table_name
+    model_class.table_name
+  end
+end
+
+class BelongsToOptions < AssocOptions
+  def initialize(name, options = {})
+    name = name.to_s.singularize
+
+    defaults = {
+      foreign_key: ("#{name.underscore}_id").to_sym,
+      class_name: name.camelcase,
+      primary_key: :id
+    }
+
+    defaults.merge(options).each do |option, opt_name|
+      send("#{option}=", opt_name)
+    end
+  end
+
+  def own_join_column
+    foreign_key
+  end
+
+  def other_join_column
+    primary_key
+  end
+end
+
+class HasManyOptions < AssocOptions
+  def initialize(name, self_class_name, options = {})
+    name = name.to_s.singularize
+    self_class_name = self_class_name.to_s.singularize
+
+    defaults = {
+      foreign_key: ("#{self_class_name.underscore}_id").to_sym,
+      class_name: name.camelcase,
+      primary_key: :id
+    }
+
+    defaults.merge(options).each do |option, opt_name|
+      send("#{option}=", opt_name)
+    end
+  end
+
+  def own_join_column
+    primary_key
+  end
+
+  def other_join_column
+    foreign_key
+  end
+end

data/lib/activeleopard/db_connection.rb

@@ -0,0 +1,136 @@
+require 'pg'
+PRINT_QUERIES = true
+
+class DBConnection
+  def self.open
+    if ENV['DATABASE_URL']
+      self.open_production
+    else
+      self.open_development
+    end
+    run_migrations
+  end
+
+  def self.open_production
+    uri = URI.parse(ENV['DATABASE_URL'])
+
+    @db = PG::Connection.new(
+      user: uri.user,
+      password: uri.password,
+      host: uri.host,
+      port: uri.port,
+      dbname: uri.path[1..-1]
+    )
+  end
+
+  def self.open_development
+    begin
+      @db = PG::Connection.open(dbname: self.database_name)
+    rescue PG::ConnectionBad => e
+      create_database!
+      retry
+    end
+
+    @db
+  end
+
+  def self.ensure_migrations_table!
+    begin
+      execute("SELECT * FROM migrations")
+    rescue PG::UndefinedTable
+      execute(<<-SQL)
+        CREATE TABLE MIGRATIONS(
+          ID SERIAL PRIMARY KEY NOT NULL,
+          NAME CHAR(50) NOT NULL,
+          CREATED_AT CHAR(50) NOT NULL
+        )
+      SQL
+    end
+  end
+
+  def self.run_migrations
+    ensure_migrations_table!
+    migrations = Dir.entries("db/migrations").reject { |fname| fname.start_with?('.') }
+    migrations.sort_by! { |fname| Integer(fname[0..1]) }
+
+    migrations.each do |file_name|
+      migration_name = file_name.match(/\w+/).to_s
+
+      next if migration_name.empty? || already_run?(migration_name)
+
+      file = File.join(Gazebo::ROOT, "db/migrations", file_name)
+      migration_sql = File.read(file)
+
+      execute(migration_sql)
+
+      record_migration!(migration_name)
+    end
+  end
+
+  def self.record_migration!(migration_name)
+    time = Time.new.strftime("%Y%m%dT%H%M")
+    here_doc = <<-SQL
+      INSERT INTO
+        migrations (name, created_at)
+      VALUES
+       ($1, $2)
+    SQL
+
+    execute(here_doc, [migration_name, time])
+  end
+
+  def self.already_run?(migration_name)
+    !!execute(<<-SQL, [migration_name]).first
+      SELECT *
+      FROM migrations
+      WHERE name = $1
+    SQL
+  end
+
+  def self.create_database!
+    master_conn = PG::Connection.connect(dbname: 'postgres')
+    master_conn.exec("CREATE DATABASE #{database_name}")
+  end
+
+  def self.database_name
+    Gazebo::ROOT.split('/').last.gsub("-", "_") + '_development'
+  end
+
+  def self.instance
+    open if @db.nil?
+
+    @db
+  end
+
+  def self.execute(*args)
+    print_query(*args)
+    instance.exec(*args)
+  end
+
+  def self.async_exec(*args)
+    print_query(*args)
+    instance.send_query(*args)
+  end
+
+  def self.get_first_row(*args)
+    print_query(*args)
+    instance.exec(*args).first
+  end
+
+  private
+
+  def self.random_color
+    [:blue, :light_blue, :red, :green, :yellow].sample
+  end
+
+  def self.print_query(query, bind_params = [])
+    return unless PRINT_QUERIES
+
+    output = query.gsub(/\s+/, ' ')
+    unless bind_params.empty?
+      output += " #{bind_params.inspect}"
+    end
+
+    puts output.colorize(random_color)
+  end
+end

data/lib/activeleopard/errors.rb

@@ -0,0 +1,5 @@
+class InvalidInput < StandardError
+end
+
+class RecordNotFound < StandardError
+end

data/lib/activeleopard/modules/associatable.rb

@@ -0,0 +1,86 @@
+module Associatable
+  def belongs_to(name, options = {})
+    options = BelongsToOptions.new(name, options)
+    assoc_options[name] = options
+
+    define_method(name) do
+      foreign_key_val = self.send(options.foreign_key)
+      return nil if foreign_key_val.nil?
+
+      options
+        .model_class
+        .where(options.primary_key => foreign_key_val)
+        .first
+    end
+  end
+
+  def has_many(name, options = {})
+    options = HasManyOptions.new(name, self, options)
+    assoc_options[name] = options
+
+    define_method(name) do
+      primary_key_val = self.send(options.primary_key)
+
+      options.model_class
+        .where(options.foreign_key => primary_key_val)
+    end
+  end
+
+  def assoc_options
+    @assoc_options ||= {}
+  end
+
+  def has_one_through(name, through_name, source_name)
+    through_options = assoc_options[through_name]
+
+    define_method(name) do
+      source_options = through_options.model_class.assoc_options[source_name]
+
+      through_table = through_options.model_class.table_name
+      source_table = source_options.model_class.table_name
+
+      datum = DBConnection.execute(<<-SQL).first
+        SELECT
+          #{source_table}.*
+        FROM
+          #{through_table}
+        JOIN
+          #{source_table}
+        ON
+          #{through_table}.#{source_options.foreign_key} =
+              #{source_table}.#{source_options.primary_key}
+        WHERE
+          #{through_table}.#{through_options.primary_key} =
+                  #{self.send(through_options.foreign_key)}
+      SQL
+
+      source_options.model_class.new(datum)
+    end
+  end
+
+  def has_many_through(name, through_name, source_name)
+    through_options = assoc_options[through_name]
+
+    define_method(name) do
+      source_options = through_options.model_class.assoc_options[source_name]
+      through_table = through_options.model_class.table_name
+      source_table = source_options.model_class.table_name
+
+      data = DBConnection.execute(<<-SQL)
+        SELECT
+          #{source_table}.*
+        FROM
+          #{through_table}
+        JOIN
+          #{source_table}
+          ON #{through_table}.#{source_options.primary_key} =
+              #{source_table}.#{source_options.foreign_key}
+        WHERE
+          #{through_table}.#{through_options.foreign_key} =
+                #{self.id}
+      SQL
+
+      data.map { |datum| source_options.model_class.new(datum) }
+    end
+  end
+end

data/lib/activeleopard/modules/searchable.rb

@@ -0,0 +1,65 @@
+module Searchable
+  def find_by(params)
+    where_clause = WhereClause.new([params])
+
+    search_datum = DBConnection.get_first_row(<<-SQL, where_clause.values)
+      SELECT
+        *
+      FROM
+        #{self.table_name}
+      #{where_clause.as_sql}
+    SQL
+
+    search_datum.nil? ? nil : self.new(search_datum)
+  end
+
+  def where(*params)
+    Relation.new(
+      {where: WhereClause.new(params)},
+      self
+    )
+  end
+
+  def find(id)
+    search_datum = DBConnection.get_first_row(<<-SQL)
+      SELECT
+        *
+      FROM
+        #{self.table_name}
+      WHERE
+        id = #{id}
+    SQL
+    raise RecordNotFound, "This record does not exist" if search_datum.nil?
+    self.new(search_datum)
+  end
+
+  def joins(association, _ = nil)
+    options = self.assoc_options[association]
+
+    Relation.new(
+      {join: JoinOptions.new(options, self.table_name)},
+      self
+    )
+  end
+
+  def select(*params)
+    Relation.new(
+      {select: SelectClause.new(params)},
+      self
+    )
+  end
+
+  def group(group_attr)
+    Relation.new(
+      {group: GroupClause.new(group_attr)},
+      self
+    )
+  end
+
+  def order(ordering_attr)
+    Relation.new(
+      {order: OrderClause.new(ordering_attr)},
+      self
+    )
+  end
+end

data/lib/activeleopard/modules/validatable.rb

@@ -0,0 +1,25 @@
+module Validatable
+  def validates(attribute, options)
+    method_name = "validate_#{attribute}"
+
+    define_method(method_name) do
+      attr_val = self.send(attribute)
+
+      if options[:presence]
+        if attr_val.nil?
+          errors[attribute] << "can't be blank"
+        end
+      end
+
+      if options[:uniqueness]
+        matching_obj = self.class.find_by(attribute => attr_val)
+
+        unless matching_obj.nil? || matching_obj.id == self.id
+          errors[attribute] << "must be unique"
+        end
+      end
+    end
+
+    self.validations << method_name
+  end
+end

data/lib/activeleopard/query_clauses/all_clauses.rb

@@ -0,0 +1,7 @@
+require_relative 'join_clause'
+require_relative 'where_clause'
+require_relative 'limit_clause'
+require_relative 'select_clause'
+require_relative 'from_clause'
+require_relative 'group_clause'
+require_relative 'order_clause'

data/lib/activeleopard/query_clauses/from_clause.rb

@@ -0,0 +1,11 @@
+class FromClause
+  attr_reader :table_name
+
+  def initialize(table_name)
+    @table_name = table_name
+  end
+
+  def as_sql
+    "FROM #{table_name}"
+  end
+end

data/lib/activeleopard/query_clauses/group_clause.rb

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

data/lib/activeleopard/query_clauses/join_clause.rb

@@ -0,0 +1,46 @@
+require_relative '../assoc_options'
+
+class JoinClause
+  def initialize(assoc_options, source_table)
+    unless assoc_options
+      raise InvalidInput, "Argument must be an association(type: symbol)"
+    end
+
+    @assoc_options = assoc_options
+    @source_table = source_table
+  end
+
+  def other_table
+    assoc_options.table_name
+  end
+
+  def on_clause
+    "#{source_table}.#{assoc_options.own_join_column}" +
+    " = " + "#{other_table}.#{assoc_options.other_join_column}"
+  end
+
+  def as_sql
+    "JOIN #{other_table} ON #{on_clause} "
+  end
+
+  attr_reader :assoc_options, :source_table
+end
+
+class JoinOptions
+  attr_reader :clauses
+
+  def initialize(assoc_options = nil, source_table = nil)
+    @clauses = []
+    if assoc_options && source_table
+      @clauses << JoinClause.new(assoc_options, source_table)
+    end
+  end
+
+  def as_sql
+    clauses.map(&:as_sql).join(" \n ")
+  end
+
+  def append(assoc_options, source_table)
+    clauses << JoinClause.new(assoc_options, source_table)
+  end
+end