bezel-app 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c2182514434b0eb19d341fb9ea1724aae0bbfd59
+  data.tar.gz: 019978d0a49e4acdf84fb2c28cddc052dc8ef04d
+SHA512:
+  metadata.gz: ba1fa4d2d752a193874a38dd91e09e507a87e438a04d49e41ff7322277b0226aca41adec8c94164d9816729b15d28ffeb75bfa265ed9db0842b595ad163afa4f
+  data.tar.gz: 34be517b8c9bd2c94641cb38b8ffa374991be236bb2bbc01ca970055ae8370ba2b6d4a46b27c58a2aa7a7d347806b07a41a4a0bdcae3c1369653f0a703d7fc8f

data/.gitconfig

@@ -0,0 +1,2 @@
+[core]
+  editor = atom --wait

data/.gitignore

@@ -0,0 +1,2 @@
+.DS_Store
+.byebug_history

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format documentation

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+gem 'rack', '~> 1.6.4'
+gem 'byebug'
+gem "rspec", "~> 3.1.0"
+gem "activesupport", '~> 4.2'
+gem 'thor'

data/Gemfile.lock

@@ -0,0 +1,44 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (4.2.7.1)
+      i18n (~> 0.7)
+      json (~> 1.7, >= 1.7.7)
+      minitest (~> 5.1)
+      thread_safe (~> 0.3, >= 0.3.4)
+      tzinfo (~> 1.1)
+    byebug (9.0.5)
+    diff-lcs (1.2.5)
+    i18n (0.7.0)
+    json (1.8.3)
+    minitest (5.9.0)
+    rack (1.6.4)
+    rspec (3.1.0)
+      rspec-core (~> 3.1.0)
+      rspec-expectations (~> 3.1.0)
+      rspec-mocks (~> 3.1.0)
+    rspec-core (3.1.7)
+      rspec-support (~> 3.1.0)
+    rspec-expectations (3.1.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.1.0)
+    rspec-mocks (3.1.3)
+      rspec-support (~> 3.1.0)
+    rspec-support (3.1.2)
+    thor (0.19.1)
+    thread_safe (0.3.5)
+    tzinfo (1.2.2)
+      thread_safe (~> 0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activesupport (~> 4.2)
+  byebug
+  rack (~> 1.6.4)
+  rspec (~> 3.1.0)
+  thor
+
+BUNDLED WITH
+   1.12.5

data/bezel-app.gemspec

@@ -0,0 +1,39 @@
+# coding: utf-8
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |spec|
+  spec.name          = 'bezel-app'
+  spec.version       = '0.0.1'
+  spec.authors       = ['Keith Thompson']
+  spec.email         = ['KeithM_Thompson@outlook.com']
+
+  spec.summary       = %q(A simple ORM and MVC inspired by Rails.)
+  spec.description   =
+            %q(Replicate much of the core functionality of rails.)
+  spec.homepage      = 'http://github.com/keithm-thompson/Bezel'
+  spec.license       = 'MIT'
+
+  # Prevent pushing this gem to RubyGems.org by setting 'allowed_push_host', or
+  # delete this section to allow pushing this gem to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata['allowed_push_host'] = 'https://rubygems.org'
+  else
+    raise 'RubyGems 2.0 or newer is required to protect against public gem pushes.'
+  end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.executables   = 'bezel-app'
+
+  spec.add_runtime_dependency 'thor', '~> 0.19'
+  spec.add_runtime_dependency 'pg', '~> 0.18'
+  spec.add_runtime_dependency 'activesupport', '~> 4.2', '>= 4.2.5.1'
+  spec.add_runtime_dependency 'pry', '~> 0.10.3'
+  spec.add_runtime_dependency 'rack', '~> 1.6', '>= 1.6.4'
+  spec.add_runtime_dependency 'fileutils', '~> 0.7'
+
+  spec.add_development_dependency 'bundler', '~> 1.11'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+end

data/bin/bezel-app

@@ -0,0 +1,130 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'thor'
+
+class Generate < Thor
+  desc 'model <name>', 'generate a model with the specified name.'
+  def model(name)
+    m_name = name.capitalize
+
+    # Writes model file
+    File.open("./app/models/#{m_name.downcase}.rb", 'w') do |f|
+      f.write("class #{m_name} < Bezel::BezelrecordBase\n\n")
+      f.write("end\n")
+      f.write("#{m_name}.finalize!")
+    end
+    migration("Create#{m_name}")
+    puts "#{m_name} model created"
+  end
+
+  desc 'controller <name>', 'generate a controller with the specified name.'
+  def controller(name)
+    c_name = name.capitalize
+
+    # Writes controller file
+    File.open("./app/controllers/#{c_name.downcase}.rb", 'w') do |f|
+      f.write("class #{c_name}Controller < Bezel::ControllerBase\n\n")
+      f.write('end')
+    end
+
+    # Creates empty views directory
+    Dir.mkdir "./app/views/#{c_name.downcase}_controller"
+    puts "#{c_name} controller created"
+  end
+
+  desc 'migration <name>', 'generates an empty sql file with a filename of the specified <name> appended to a timestamp'
+  def migration(name)
+    # Create a timestamp
+    ts = Time.now.to_s.split(' ').take(2).join('').split('').map(&:to_i).join
+    require 'active_support/inflector'
+    filename = "#{ts}__#{name.underscore.downcase}"
+
+    # Create the migration file
+    File.open("./db/migrate/#{filename}.sql", 'w') do |f|
+      f.write "CREATE TABLE IF NOT EXISTS #{name} (\n"
+      f.write "\tid SERIAL PRIMARY KEY,\n"
+      f.write "\tname VARCHAR(255) NOT NULL"
+      f.write ');'
+    end
+  end
+end
+
+# Top-level command for manipulating the database file.
+class Db < Thor
+  desc 'create', 'creates the DB'
+  def create
+    require_relative '../lib/db_connection'
+    Bezel::DBConnection.reset
+    puts 'db created!'
+  end
+
+  desc 'migrate', 'runs pending migrations'
+  def migrate
+    # Creates Version table if necessary,
+    # then runs needed migrations in order.
+    require_relative '../lib/db_connection'
+    Bezel::DBConnection.migrate
+    puts 'migrated!'
+  end
+
+  desc 'seed', 'seeds the DB'
+  def seed
+    require_relative '../lib/bezel'
+    Bezel::Seed.populate
+    puts 'db seeded!'
+  end
+
+  desc 'reset', 'resets the DB and seeds it'
+  def reset
+    create
+    migrate
+    seed
+    puts 'db reset!'
+  end
+end
+
+class CLI < Thor
+  register(Generate, 'generate', 'generate <command>', 'Generates a model or controller.')
+  register(Db, 'db', 'db <command>', 'Accesses commands for the DB.')
+
+  desc 'g', 'alias of generate subcommand'
+  subcommand 'g', Generate
+
+  desc 'server', 'starts the Bezel server'
+  def server
+    require_relative '../lib/bezel'
+    Bezel::ServerConnection.start
+  end
+
+  desc 'new', 'creates a new Bezel app'
+  def new(name)
+    Dir.mkdir "./#{name}"
+    Dir.mkdir "./#{name}/config"
+
+    File.open("./#{name}/config/database.yml", 'w') do |f|
+      f.write("database: #{name}")
+    end
+
+    Dir.mkdir "./#{name}/app"
+    Dir.mkdir "./#{name}/app/models"
+    Dir.mkdir "./#{name}/app/views"
+    Dir.mkdir "./#{name}/app/controllers"
+    File.open("./#{name}/app/controllers/application_controller.rb", 'w') do |f|
+      f.write File.read(File.expand_path('../../template/app/controllers/application_controller.rb', __FILE__))
+    end
+    File.open("./#{name}/config/routes.rb", 'w') do |f|
+      f.write File.read(File.expand_path('../../template/config/routes.rb', __FILE__))
+    end
+    Dir.mkdir "./#{name}/db"
+    Dir.mkdir "./#{name}/db/migrate"
+    File.open("./#{name}/db/seeds.rb", 'w') do |f|
+      f.write File.read(File.expand_path('../../template/db/seeds.rb', __FILE__))
+    end
+    File.open("./#{name}/Gemfile", 'w') do |f|
+      f.write File.read(File.expand_path('../../template/Gemfile', __FILE__))
+    end
+  end
+end
+
+CLI.start(ARGV)

data/lib/bezel.rb

@@ -0,0 +1,15 @@
+module Bezel
+end
+
+require_relative 'bezelrecord_base/bezelrecord_base'
+require_relative 'controller_base'
+
+Dir.glob('./app/models/*.rb') { |file| require file }
+Dir.glob('./app/controllers/*.rb') { |file| require file }
+
+require './db/seeds'
+
+require_relative 'db_connection'
+require_relative 'router'
+require_relative 'server_connection'
+require_relative 'session'

data/lib/bezelrecord_base/associatable.rb

@@ -0,0 +1,114 @@
+require_relative 'searchable'
+require 'active_support/inflector'
+
+class AssocOptions
+  attr_accessor(
+    :foreign_key,
+    :class_name,
+    :primary_key
+  )
+
+  def model_class
+    @model_class = class_name.constantize
+  end
+
+  def table_name
+    @table_name = model_class.table_name
+  end
+end
+
+class BelongsToOptions < AssocOptions
+  def initialize(name, options = {})
+    @foreign_key = options[:foreign_key] || (name.to_s + "Id").underscore.to_sym
+    @primary_key = options[:primary_key] || :id
+    @class_name = options[:class_name] || name.to_s.camelcase
+  end
+end
+
+class HasManyOptions < AssocOptions
+  def initialize(name, self_class_name, options = {})
+
+    @foreign_key = options[:foreign_key] || (self_class_name.to_s + "Id").underscore.to_sym
+    @primary_key = options[:primary_key] || :id
+    @class_name = options[:class_name] || name.to_s.singularize.camelcase
+  end
+end
+
+module Associatable
+  def belongs_to(name, options = {})
+    options = BelongsToOptions.new(name, options)
+    @prior_options = assoc_options
+    @prior_options[name] = options
+
+    define_method(options.class_name.downcase.to_sym) do
+      foreign_key = send(options.foreign_key)
+      the_class = options.model_class
+      the_class.where(options.primary_key => foreign_key).first
+    end
+  end
+
+  def has_many(name, options = {})
+    options = HasManyOptions.new(name, self,  options)
+    @prior_options = assoc_options
+    if @prior_options[name.to_s.singularize.to_sym].nil?
+      @prior_options[name.to_s.singularize.to_sym] = options
+    else
+      @prior_options[name.to_s.singularize.to_sym] << options
+    end
+    define_method(options.table_name.to_sym) do
+      primary_key = send(options.primary_key)
+      options.model_class.where(options.foreign_key => primary_key)
+    end
+  end
+
+  def assoc_options
+    @prior_options ||= {}
+  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]
+      search_by = send(through_options.foreign_key)
+
+      results = DBConnection.execute(<<-SQL, search_by)
+        SELECT
+        #{source_options.table_name}.*
+        FROM
+        #{through_options.table_name}
+        JOIN
+        #{source_options.table_name} ON #{source_options.table_name}.#{source_options.primary_key.to_s} = #{through_options.table_name}.#{source_options.foreign_key.to_s}
+        WHERE
+        #{through_options.table_name}.#{through_options.primary_key} = ?
+      SQL
+      source_options.model_class.new(results.first)
+    end
+  end
+
+  def has_many_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.to_s.singularize.to_sym]
+      search_classes = through_options.model_class.where(through_options.foreign_key => send(source_options.primary_key))
+
+      search_by = []
+      search_classes.each do |classes|
+        search_by << classes.send(source_options.primary_key)
+      end
+
+      results = DBConnection.execute(<<-SQL, *search_by)
+        SELECT
+        #{source_options.table_name}.*
+        FROM
+        #{through_options.table_name}
+        JOIN
+        #{source_options.table_name} ON #{source_options.table_name}.#{source_options.foreign_key.to_s} = #{through_options.table_name}.#{through_options.primary_key.to_s}
+        WHERE
+        #{through_options.table_name}.#{through_options.primary_key} IN (#{Array.new(search_by.length,"?").join(", ")})
+        SQL
+      results.map{|result| source_options.model_class.new(result)}
+    end
+  end
+end

data/lib/bezelrecord_base/bezelrecord_base.rb

@@ -0,0 +1,122 @@
+require 'active_support/inflector'
+require_relative '../../../db/lib/db_connection'
+require_relative 'associatable'
+require_relative 'searchable'
+
+class BezelrecordBase
+  extend Associatable
+  extend Searchable
+  
+  def self.columns
+    unless @columns
+      temp_columns = DBConnection.execute2(<<-SQL)
+        SELECT
+          *
+        FROM
+          #{table_name}
+      SQL
+      @columns = temp_columns.first.map { |column| column.to_sym }
+    end
+    @columns
+  end
+
+  def self.finalize!
+    columns.each do |column|
+
+      define_method("#{column}") do
+        @attributes = self.attributes
+        @attributes[column]
+      end
+
+      define_method("#{column}=") do |value|
+        @attributes = self.attributes
+        @attributes[column] = value
+      end
+    end
+  end
+
+  def self.table_name=(table_name)
+    @table_name = table_name
+  end
+
+  def self.table_name
+    @table_name || to_s.tableize
+  end
+
+  def self.all
+    results = DBConnection.execute(<<-SQL)
+      SELECT
+        #{table_name}.*
+      FROM
+        #{table_name}
+    SQL
+    parse_all(results)
+  end
+
+  def self.parse_all(results)
+    objects = results.map do |object|
+      self.new(object)
+    end
+  end
+
+  def self.find(id)
+    object = DBConnection.execute(<<-SQL, id)
+      SELECT
+        *
+      FROM
+        #{table_name}
+      WHERE
+        id = ?
+      LIMIT
+        1
+    SQL
+    nil || object.map {|obj| self.new(obj)}.first
+  end
+
+  def initialize(params = {})
+    table_columns = self.class.columns
+
+    params.each do |key, value|
+      raise "unknown attribute '#{key}'" unless table_columns.include?(key.to_sym)
+      send("#{key}=",value)
+    end
+  end
+
+  def attributes
+  @attributes = @attributes || {}
+  end
+
+  def attribute_values
+    table_cols = self.class.columns
+    table_cols
+    table_cols.map{ |col| self.send("#{col}")}
+  end
+
+  def insert
+    columns = self.class.columns
+
+    DBConnection.execute(<<-SQL, *attribute_values)
+      INSERT INTO
+        #{self.class.table_name} (#{columns.join(", ")})
+      VALUES
+        (#{Array.new(columns.length,"?").join(", ")})
+      SQL
+      self.send(:id=,DBConnection.last_insert_row_id)
+  end
+
+  def update
+    DBConnection.execute(<<-SQL,*attribute_values[1..-1], attribute_values.first)
+      UPDATE
+        #{self.class.table_name}
+      SET
+        #{self.class.columns[1..-1].map{|col| "#{col} = ?"}.join(", ")}
+      WHERE
+        id = ?
+      SQL
+
+  end
+
+  def save
+    id.nil? ? insert : update
+  end
+end

data/lib/bezelrecord_base/searchable.rb

@@ -0,0 +1,18 @@
+require_relative 'db_connection'
+
+module Searchable
+  def where(params)
+    where_line = params.keys.map{|key| "#{key} = ?"}
+    results = DBConnection.execute(<<-SQL, *params.values)
+      SELECT
+        *
+      FROM
+        #{table_name}
+      WHERE
+        #{where_line.join(" AND ")}
+    SQL
+    parse_all(results)
+  end
+
+
+end

data/lib/controller_base.rb

@@ -0,0 +1,78 @@
+require 'active_support'
+require 'active_support/core_ext'
+require 'erb'
+require_relative './session'
+require_relative './flash'
+
+class ControllerBase
+  attr_reader :req, :res, :params, :flash
+
+  def self.protect_from_forgery
+    @@csrf_auth = true
+  end
+
+  def initialize(req, res, route_params = {})
+    @req = req
+    @res = res
+    @params = req.params.merge(route_params)
+    @flash = Flash.new(req)
+    @params['authenticity_token'] ||= SecureRandom.base64
+  end
+
+  def form_authenticity_token
+    @res.set_cookie('authenticity_token',@params['authenticity_token'])
+    @params['authenticity_token']
+  end
+
+  def check_authenticity_token(token = "")
+    @params['authenticity_token'] == token
+  end
+
+
+  def already_built_response?
+    !!@already_built_response
+  end
+
+
+  def redirect_to(url)
+    raise 'You cannot call render more than once' if already_built_response?
+    @res.status = 302
+    @res['Location'] = url
+    @already_built_response = true
+
+    session.store_session(@res)
+  end
+
+  def render_content(content, content_type)
+    raise 'You cannot call render more than once' if already_built_response?
+    @res['Content-Type'] = content_type
+    @res.write(content)
+    @already_built_response = true
+
+    session.store_session(@res)
+  end
+
+  def render(template_name)
+    file_name = "views/"
+    file_name += "#{self.class.to_s.underscore}/"
+    file_name += "#{template_name}.html.erb"
+    content = ERB.new(File.read(file_name)).result(binding)
+
+    render_content(content, "text/html")
+  end
+
+  def session
+    @session ||= Session.new(@req)
+  end
+
+  def invoke_action(name)
+    if @@csrf_auth && @req.request_method != "GET"
+      unless check_authenticity_token(@req.cookies['authenticity_token'])
+        raise "Invalid authenticity token"
+      end
+    end
+
+    send(name)
+    render(name) unless already_built_response?
+  end
+end

data/lib/db_connection.rb

@@ -0,0 +1,117 @@
+require 'pg'
+require 'yaml'
+
+PRINT_QUERIES = ENV['PRINT_QUERIES'] == 'true'
+MIGRATIONS = Dir.glob('./db/migrate/*.sql').to_a
+
+module Bezel
+  class DBConnection
+    def self.app_name
+      YAML.load_file(Dir.pwd + '/config/database.yml')['database']
+    end
+
+    def self.add_to_version(file)
+      name = parse_migration_file(file)
+      execute(<<-SQL, [name])
+        INSERT INTO
+          version (name)
+        VALUES
+          ($1);
+      SQL
+    end
+
+    def self.columns(table_name)
+      columns = instance.exec(<<-SQL)
+        SELECT
+          attname
+        FROM
+          pg_attribute
+        WHERE
+          attrelid = '#{table_name}'::regclass AND
+          attnum > 0 AND
+          NOT attisdropped
+      SQL
+
+      columns.map { |col| col['attname'].to_sym }
+    end
+
+    def self.ensure_version_table
+      table = nil
+
+      if table.nil?
+        execute(<<-SQL)
+          CREATE TABLE IF NOT EXISTS version (
+            id SERIAL PRIMARY KEY,
+            name VARCHAR(255) NOT NULL
+          );
+        SQL
+      end
+    end
+
+    def self.execute(*args)
+      print_query(*args)
+      instance.exec(*args)
+    end
+
+    def self.instance
+      open if @db.nil?
+
+      @db
+    end
+
+    def self.migrate
+      ensure_version_table
+      to_migrate = MIGRATIONS.reject { |file| migrated?(file) }
+      to_migrate.each do |file|
+        add_to_version(file)
+        `psql -d #{app_name} -a -f #{file}`
+      end
+    end
+
+    def self.migrated?(file)
+      name = parse_migration_file(file)
+      result = execute(<<-SQL, [name])
+        SELECT
+          *
+        FROM
+          version
+        WHERE
+          name = $1;
+      SQL
+      !!result.first
+    end
+
+    def self.parse_migration_file(file)
+      filename = File.basename(file).split('.').first
+      u_idx = filename.index('_')
+      filename[0..u_idx - 1]
+    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
+
+    def self.open
+      @db = PG::Connection.new(
+        dbname: app_name,
+        port: 5432
+      )
+    end
+
+    def self.reset
+      commands = [
+        "dropdb #{app_name}",
+        "createdb #{app_name}"
+      ]
+
+      commands.each { |command| `#{command}` }
+    end
+  end
+end

data/lib/flash.rb

@@ -0,0 +1,29 @@
+require 'json'
+
+class Flash
+  def initialize(req)
+    if req.cookies['_bezel_flash']
+      @flash = JSON.parse(req.cookies['_bezel_flash'])
+    else
+      @flash = {}
+    end
+    @flash_now = {}
+  end
+
+  def []=(key,val)
+    @flash[key] = val
+  end
+
+  def [](key)
+    return @flash_now[key] if @flash_now[key]
+    @flash[key.to_s]
+  end
+
+  def store_flash(res)
+    res.set_cookie('_bezel_flash', value: @flash.to_json, path: '/')
+  end
+
+  def now
+    @flash_now
+  end
+end

data/lib/router.rb

@@ -0,0 +1,60 @@
+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, @action_name = controller_class, action_name
+  end
+
+  def matches?(req)
+    pattern =~ req.path && http_method == req.request_method.downcase.to_sym
+  end
+
+  def run(req, res)
+    raise 'no action' unless matches?(req)
+    route_matches = @pattern.match(req.path)
+    route_params = {}
+    route_matches.names.each do |name|
+      route_params[name] = route_matches[name]
+    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
+
+  def add_route(pattern, method, controller_class, action_name)
+    @routes << 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, method|
+      add_route(pattern, http_method, controller_class, method)
+    end
+  end
+
+  def match(req)
+    @routes.each do |route|
+      return route if route.matches?(req)
+    end
+    nil
+  end
+
+  def run(req, res)
+    route = match(req)
+    return res.status = 404 unless route
+    route.run(req,res)
+  end
+end

data/lib/session.rb

@@ -0,0 +1,24 @@
+require 'json'
+
+class Session
+  def initialize(req)
+    if req.cookies['_']
+      @cookie =  JSON.parse(req.cookies['_bezel'])
+    else
+      @cookie = {}
+    end
+  end
+
+  def [](key)
+    @cookie[key]
+  end
+
+  def []=(key, val)
+    @cookie[key] = val
+  end
+
+  def store_session(res)
+    json_cookie = @cookie.to_json
+    res.set_cookie('_bezel', value: json_cookie, path: '/' )
+  end
+end

data/lib/show_exceptions.rb

@@ -0,0 +1,24 @@
+require 'erb'
+class ShowExceptions
+  attr_reader :app
+
+  def initialize(app)
+    @app = app
+  end
+
+  def call(env)
+    begin
+      app.call(env)
+    rescue Exception => e
+      render_exception(e)
+    end
+  end
+
+  private
+
+  def render_exception(e)
+    response = Rack::Response.new([], 500, 'Content_Type'=> 'text/html')
+    response.write(e.message)
+    response.finish
+  end
+end

data/lib/static_assets.rb

@@ -0,0 +1,36 @@
+class StaticAssets
+  def initialize(app)
+    @app = app
+  end
+
+  def call(env)
+    file_path = "." + env['PATH_INFO']
+    res = Rack::Response.new
+    extension = /\.(\w*$)/.match(file_path)[1]
+    begin
+      res['Content-Type'] = set_content_type(extension)
+      content = File.read(file_path)
+      res.write(content)
+    rescue
+      res.status = 404
+    end
+
+    res.finish
+  end
+end
+
+private
+def set_content_type(extension)
+  case extension
+    when "txt"
+       "text/plain"
+    when "jpg"
+      "image/jpeg"
+    when "zip"
+      "application/zip"
+    when "png"
+      "image/png"
+    else
+      raise 'extension not supported'
+  end
+end

data/template/app/controllers/application_controller.rb

@@ -0,0 +1,3 @@
+class ApplicationController < Bezel::ControllerBase
+  ApplicationController.protect_from_forgery
+end

data/template/config/routes.rb

@@ -0,0 +1,9 @@
+ROUTER = Bezel::Router.new
+ROUTER.draw do
+  #Some sample routes:
+
+  # get Regexp.new("^/cats/new$"), CatsController, :new
+  # post Regexp.new("^/cats/create$"), CatsController, :create
+  # get Regexp.new("^/cats$"), CatsController, :index
+  # get Regexp.new("^/cats/(?<cat_id>\\d+)$"), CatsController, :show
+end

data/template/db/seeds.rb

@@ -0,0 +1,7 @@
+module Bezel
+  class Seed
+    def self.populate
+
+    end
+  end
+end

data/views/cats_controller/index.html.erb

@@ -0,0 +1,3 @@
+<h1>ALL THE CATS</h1>
+<pre><%= @cats.to_s %></pre>
+<a href="/cats/new">New cat!</a>

data/views/cats_controller/new.html.erb

@@ -0,0 +1,11 @@
+<form action="/cats" method="POST">
+  <label>Name
+    <input type="text" name="cat[name]" value="<%= @cat.name %>">
+  </label>
+
+  <label>Owner
+    <input type="text" name="cat[owner]" value="<%= @cat.owner %>">
+  </label>
+
+  <input type="submit">
+</form>

data/views/dogs_controller/index.html.erb

@@ -0,0 +1,8 @@
+<h1>ALL THE DOGS</h1>
+
+<% if flash[:notice] %>
+  Notice: <%= flash[:notice] %>
+<% end %>
+
+<pre>Dog Data: <%= @dogs.to_s %></pre>
+<a href="/dogs/new">New Dog!</a>

data/views/dogs_controller/new.html.erb

@@ -0,0 +1,19 @@
+<% if flash[:errors] %>
+  <% flash[:errors].each do |error| %>
+    <%= error %>
+  <% end %>
+<% end %>
+
+<form action="/dogs" method="POST">
+  <label>Name
+    <input type="text" name="dog[name]" value="<%= @dog.name %>">
+  </label>
+    <input type="hidden" name="authenticity_token" value="<%= form_authenticity_token %>">
+
+
+  <label>Owner
+    <input type="text" name="dog[owner]" value="<%= @dog.owner %>">
+  </label>
+
+  <input type="submit">
+</form>

data/views/dogs_controller/show.html.erb

@@ -0,0 +1 @@
+<%= link_to "all dogs", dogs_path %>

data/views/my_controller/counting_show.html.erb

@@ -0,0 +1 @@
+<%= session["count"] %>

data/views/my_controller/show.html.erb

@@ -0,0 +1 @@
+<%= (1..10).to_a.join(", ") %>

metadata

@@ -0,0 +1,214 @@
+--- !ruby/object:Gem::Specification
+name: bezel-app
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Keith Thompson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-10-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.19'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.19'
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.18'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.18'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.2.5.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.2.5.1
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.10.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.10.3
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.6.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.6.4
+- !ruby/object:Gem::Dependency
+  name: fileutils
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+- !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: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Replicate much of the core functionality of rails.
+email:
+- KeithM_Thompson@outlook.com
+executables:
+- bezel-app
+extensions: []
+extra_rdoc_files: []
+files:
+- ".byebug_history"
+- ".gitconfig"
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- Gemfile.lock
+- bezel-app.gemspec
+- bin/bezel-app
+- lib/bezel.rb
+- lib/bezelrecord_base/associatable.rb
+- lib/bezelrecord_base/bezelrecord_base.rb
+- lib/bezelrecord_base/searchable.rb
+- lib/controller_base.rb
+- lib/db_connection.rb
+- lib/flash.rb
+- lib/router.rb
+- lib/session.rb
+- lib/show_exceptions.rb
+- lib/static_assets.rb
+- template/app/controllers/application_controller.rb
+- template/config/routes.rb
+- template/db/seeds.rb
+- views/cats_controller/index.html.erb
+- views/cats_controller/new.html.erb
+- views/dogs_controller/index.html.erb
+- views/dogs_controller/new.html.erb
+- views/dogs_controller/show.html.erb
+- views/dummy_controller/index.html.erb
+- views/my_controller/counting_show.html.erb
+- views/my_controller/show.html.erb
+homepage: http://github.com/keithm-thompson/Bezel
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+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.2.2
+signing_key: 
+specification_version: 4
+summary: A simple ORM and MVC inspired by Rails.
+test_files: []