algernon 0.1.0

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "algernon"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/algernon/application.rb

@@ -0,0 +1,53 @@
+require "rack"
+require "utility/request_handler"
+require "utility/method_override"
+
+module Algernon
+  class Application
+    attr_reader :request, :verb, :path, :router
+
+    alias_method :routes, :router
+
+    def initialize
+      @router = Routing::Router.new
+    end
+
+    def call(env)
+      env = MethodOverride.apply_to(env)
+      @request = Rack::Request.new(env)
+      if router.has_routes?
+        respond_to_request
+      else
+        default_response
+      end
+    end
+
+    def respond_to_request
+      route = router.get_match(request.request_method, request.path_info)
+      if route
+        handler = RequestHandler.new(request, route)
+        handler.response
+      else
+        page_not_found
+      end
+    end
+
+    def default_response
+      Rack::Response.new(
+        "<center><b>Algernon::Penny wise, Pound foolish</center>",
+        200,
+        "Content-Type" => "text/html"
+      )
+    end
+
+    def page_not_found
+      Rack::Response.new(
+        "<center><h1>404 Error</h1>Page not found</center>",
+        404,
+        "Content-Type" => "text/html"
+      )
+    end
+
+    private :respond_to_request, :default_response, :page_not_found
+  end
+end

data/lib/algernon/controller/base_controller.rb

@@ -0,0 +1,54 @@
+require "erubis"
+require "active_support/core_ext/hash/indifferent_access"
+
+module Algernon
+  class BaseController
+    attr_reader :request
+    def initialize(request)
+      @request = request
+    end
+
+    def get_response
+      @response
+    end
+
+    def render(view_name, locals = {})
+      filename = File.join(APP_ROOT,
+                           "app",
+                           "views",
+                           controller_for_views,
+                           "#{view_name}.html.erb"
+                          )
+      template = File.read(filename)
+      parameters = process_view_variables(locals)
+      res_body = Erubis::Eruby.new(template).result(parameters)
+      response_setter(res_body)
+    end
+
+    def process_view_variables(locals)
+      hash = {}
+      vars = instance_variables
+      vars.each { |name| hash[name] = instance_variable_get(name) }
+
+      hash.merge(locals)
+    end
+
+    def response_setter(body, status = 200, headers = {})
+      @response = Rack::Response.new(body, status, headers)
+    end
+
+    def redirect_to(destination)
+      response_setter([], 302, "Location" => destination)
+    end
+
+    def params
+      request.params.with_indifferent_access
+    end
+
+    def controller_for_views
+      controller_class = self.class
+      controller_class = controller_class.to_s.gsub(/Controller$/, "")
+      controller_class.snakify
+    end
+  end
+end

data/lib/algernon/dependencies.rb

@@ -0,0 +1,7 @@
+class Object
+  def self.const_missing(c)
+    const = c.to_s
+    require c.to_s.snakify
+    const.constantify
+  end
+end

data/lib/algernon/model/model.rb

@@ -0,0 +1,101 @@
+require "sqlite3"
+require "algernon/model/table_maker"
+require "algernon/model/orm"
+
+module Algernon
+  class Model
+    extend Algernon::TableMaker
+    extend Algernon::Orm
+
+    DB ||= SQLite3::Database.new(File.join("database", "data.sqlite"))
+
+    def initialize
+    end
+
+    def save
+      if id
+        query = "UPDATE #{self.class.table_name} "\
+                "SET #{update_field_set} "\
+                "WHERE id = ?"
+        DB.execute(query, table_values, id)
+      else
+        query = "INSERT INTO #{self.class.table_name} "\
+                "(#{table_fields}) "\
+                "VALUES(#{values_placeholders})"
+        DB.execute(query, table_values)
+
+        self.id = DB.execute("SELECT last_insert_rowid()")
+      end
+      self.class.find(id)
+    end
+
+    def update(parameters)
+      parameters.each do |key, value|
+        send("#{key}=", value)
+      end
+
+      save
+    end
+
+    def destroy
+      DB.execute("DELETE FROM #{self.class.table_name} WHERE id= ?", id)
+    end
+
+    def table_fields
+      columns_except_id.join(", ")
+    end
+
+    def columns_except_id
+      self.class.columns_array.without_id.with_value(self)
+    end
+
+    def values_placeholders
+      count = columns_except_id.count
+      (["?"] * count).join(", ")
+    end
+
+    def table_values
+      values = []
+      columns_except_id.each do |field|
+        values << send(field)
+      end
+      values
+    end
+
+    def update_field_set
+      values = []
+      columns_except_id.each do |field|
+        values << "#{field} = ? "
+      end
+      values.join(", ")
+    end
+
+    class << self
+      attr_reader :table_name, :fields
+
+      def to_table(table_name)
+        @table_name = table_name.to_s
+        @fields = {}
+        property :id, type: :integer, primary_key: true
+      end
+
+      def property(field_name, options = {})
+        @fields[field_name] = options
+        attr_accessor field_name
+      end
+
+      def create_table
+        query = "CREATE TABLE IF NOT EXISTS #{@table_name}"\
+                "(#{fields_builder(@fields)})"
+        DB.execute(query)
+      end
+
+      def columns_array
+        @columns_array ||= fields.keys
+      end
+    end
+
+    private :table_fields, :columns_except_id, :values_placeholders,
+            :table_values, :update_field_set
+  end
+end

data/lib/algernon/model/orm.rb

@@ -0,0 +1,51 @@
+module Algernon
+  module Orm
+    DB ||= SQLite3::Database.new(File.join("database", "data.sqlite"))
+
+    def create(params)
+      model = new
+      params.each do |key, value|
+        model.send("#{key}=", value)
+      end
+
+      model.save
+    end
+
+    def all
+      fields = columns_array.join(", ")
+      data = DB.execute("SELECT id, #{fields} FROM #{table_name}")
+      data.map! do |row|
+        row_to_model(row)
+      end
+
+      data
+    end
+
+    def row_to_model(row)
+      model = new
+
+      columns_array.each_with_index do |field, index|
+        model.send("#{field}=", row[index + 1]) if row
+      end
+
+      model
+    end
+
+    def find(id)
+      fields = columns_array.join(", ")
+      row = DB.execute(
+        "SELECT id, #{fields} FROM #{table_name} WHERE id = ?",
+        id
+      ).first
+      row_to_model(row) if row
+    end
+
+    def destroy(id)
+      DB.execute("DELETE FROM #{table_name} WHERE id= ?", id)
+    end
+
+    def destroy_all
+      DB.execute("DELETE FROM #{table_name}")
+    end
+  end
+end

data/lib/algernon/model/table_maker.rb

@@ -0,0 +1,39 @@
+module Algernon
+  module TableMaker
+    def fields_builder(fields)
+      columns_definition = ""
+      fields.each do |field, constraints|
+        columns_definition += field.to_s
+
+        constraints.each do |constraint_type, value|
+          columns_definition += " "
+          columns_definition += send(constraint_type, value)
+        end
+        columns_definition += ","
+      end
+      columns_definition[0..-2]
+    end
+
+    def primary_key(value)
+      return "PRIMARY KEY" if value
+      ""
+    end
+
+    def auto_increment(value)
+      "AUTOINCREMENT" if value
+    end
+
+    def type(value)
+      value.to_s.upcase
+    end
+
+    def nullable(value)
+      return "NOT NULL" unless value
+      "NULL"
+    end
+
+    def default(value)
+      "DEFAULT `#{value}`"
+    end
+  end
+end

data/lib/algernon/routing/finder.rb

@@ -0,0 +1,44 @@
+module Algernon
+  module Routing
+    class Finder
+      attr_reader :controller_name, :action, :path_regex, :url_placeholders
+      def initialize(path_regex, to, url_placeholders = {})
+        @controller_name, @action = get_controller_and_action(to)
+        @path_regex = path_regex
+        @url_placeholders = url_placeholders
+      end
+
+      def controller
+        Object.const_get(controller_name.camelify)
+      end
+
+      def get_url_parameters(actual_path)
+        parameters = {}
+        path = actual_path.split("/")
+        url_placeholders.each do |index, key|
+          parameters[key] = path[index.to_i]
+        end
+        parameters
+      end
+
+      def check_path(path)
+        (path_regex =~ path) == 0
+      end
+
+      def ==(other)
+        controller_name == other.controller_name &&
+          action == other.action &&
+          path_regex == other.path_regex &&
+          url_placeholders == other.url_placeholders
+      end
+
+      private
+
+      def get_controller_and_action(to)
+        controller, action = to.split("#")
+        controller_name = controller + "_controller"
+        [controller_name, action]
+      end
+    end
+  end
+end

data/lib/algernon/routing/route.rb

@@ -0,0 +1,31 @@
+module Algernon
+  module Routing
+    module Route
+      def root(target)
+        get("/", to: target)
+      end
+
+      def resources(controller, options = {})
+        actions = detect_action(options)
+
+        # rubocop:disable Metrics/LineLength
+        get("/#{controller}", to: "#{controller}#index") if actions.include?(:index)
+        get("/#{controller}/new", to: "#{controller}#new") if actions.include?(:new)
+        post("/#{controller}", to: "#{controller}#create") if actions.include?(:create)
+        get("/#{controller}/:id", to: "#{controller}#show") if actions.include?(:show)
+        get("/#{controller}/:id/edit", to: "#{controller}#edit") if actions.include?(:edit)
+        put("/#{controller}/:id", to: "#{controller}#update") if actions.include?(:update)
+        patch("/#{controller}/:id", to: "#{controller}#update") if actions.include?(:update)
+        delete("/#{controller}/:id", to: "#{controller}#destroy") if actions.include?(:destroy)
+        # rubocop:enable Metrics/LineLength
+      end
+
+      def detect_action(options)
+        actions = [:index, :new, :create, :show, :edit, :update, :destroy]
+        actions -= options[:except] if options.key?(:except)
+        actions &= options[:only] if options.key?(:only)
+        actions
+      end
+    end
+  end
+end

data/lib/algernon/routing/router.rb

@@ -0,0 +1,81 @@
+require "algernon/routing/finder"
+require "algernon/routing/route"
+
+module Algernon
+  module Routing
+    class Router
+      include Algernon::Routing::Route
+      attr_accessor :routes, :url_placeholders, :part_regex
+
+      HTTP_VERBS = %w(get post put patch delete).freeze
+
+      def initialize
+        @routes = {}
+        @url_placeholders = {}
+        @part_regex = []
+        http_verb_creator
+      end
+
+      def draw(&block)
+        instance_eval(&block)
+      end
+
+      def has_routes?
+        true unless routes.empty?
+      end
+
+      def get_match(http_verb, path)
+        http_verb = http_verb.downcase
+        routes[http_verb].detect do |route|
+          route.check_path(path)
+        end
+      end
+
+      def http_verb_creator
+        self.class.class_eval do
+          HTTP_VERBS.each do |http_verb|
+            define_method(http_verb) do |path, to:|
+              process_and_store_route(http_verb, path, to)
+            end
+          end
+        end
+      end
+
+      def process_and_store_route(http_verb, path, to)
+        regex_parts, url_placeholders = extract_regex_and_placeholders(path)
+        path_regex = convert_regex_parts_to_path(regex_parts)
+        route_object = Algernon::Routing::Finder.new(
+          path_regex, to, url_placeholders
+        )
+        routes[http_verb.downcase.freeze] ||= []
+        routes[http_verb.downcase] << route_object
+      end
+
+      def extract_regex_and_placeholders(path)
+        path.path_format!
+
+        @part_regex = []
+        @url_placeholders = {}
+        path.split("/").each_with_index do |path_part, index|
+          store_part_and_placeholder(path_part, index)
+        end
+
+        [part_regex, url_placeholders]
+      end
+
+      def store_part_and_placeholder(path_part, index)
+        if path_part.start_with?(":")
+          url_placeholders[index] = path_part.delete(":").freeze
+          part_regex << "[a-zA-Z0-9_]+"
+        else
+          part_regex << path_part
+        end
+      end
+
+      def convert_regex_parts_to_path(regex_match)
+        regex_string = "^" + regex_match.join("/") + "/*$"
+        Regexp.new(regex_string)
+      end
+    end
+  end
+end

data/lib/algernon/version.rb

@@ -0,0 +1,3 @@
+module Algernon
+  VERSION = "0.1.0".freeze
+end

data/lib/algernon.rb

@@ -0,0 +1,11 @@
+require "algernon/version"
+require "algernon/dependencies"
+require "utility/string_utils"
+require "algernon/routing/router"
+require "algernon/routing/route"
+require "algernon/routing/finder"
+require "algernon/application"
+require "algernon/controller/base_controller"
+require "utility/array_utils"
+require "algernon/model/model"
+require "pry"

data/lib/utility/array_utils.rb

@@ -0,0 +1,9 @@
+class Array
+  def without_id
+    reject { |key| key == :id }
+  end
+
+  def with_value(base)
+    reject { |field| base.send(field).nil? }
+  end
+end

data/lib/utility/method_override.rb

@@ -0,0 +1,11 @@
+require "rack"
+
+class MethodOverride
+  def self.apply_to(env)
+    request = Rack::Request.new(env)
+    env["REQUEST_METHOD"] = request.params["_method"].
+                            upcase if request.params["_method"]
+
+    env
+  end
+end

data/lib/utility/request_handler.rb

@@ -0,0 +1,38 @@
+module Algernon
+  class RequestHandler
+    attr_reader :request, :route, :response
+
+    def initialize(request, route)
+      @request = request
+      @route = route
+      process_request
+    end
+
+    private
+
+    def process_request
+      params = collage_parameters
+
+      request.instance_variable_set "@params", params
+
+      controller_constant = route.controller
+      controller_class = controller_constant.new(request)
+
+      @response = controller_response(controller_class, route.action.to_sym)
+    end
+
+    def collage_parameters
+      route_url_params = route.get_url_parameters(request.path_info)
+      request.params.merge(route_url_params)
+    end
+
+    def controller_response(controller, action)
+      controller.send(action)
+
+      unless controller.get_response
+        controller.render(action)
+      end
+      controller.get_response
+    end
+  end
+end

data/lib/utility/string_utils.rb

@@ -0,0 +1,39 @@
+class String
+  def snakify
+    gsub!("::", "/")
+    gsub!(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+    gsub!(/([a-z\d])([A-Z])/, '\1_\2')
+    tr!("-", "_")
+    downcase!
+    self
+  end
+
+  def camelify
+    return self if self !~ /_/ && self =~ /[A-Z]+.*/
+    split("_").map(&:capitalize).join
+  end
+
+  def constantify
+    Object.const_get(self)
+  end
+
+  def pluralize
+    gsub!(/([^aeiouy]|qu)y$/i, '\1ies')
+    gsub!(/(ss|z|ch|sh|x)$/i, '\1es')
+    gsub!(/(is)$/i, "es")
+    gsub!(/(f|fe)$/i, "ves")
+    gsub!(/(ex|ix)$/i, "ices")
+    gsub!(/(a)$/i, "ae")
+    gsub!(/(um|on)$/i, "a")
+    gsub!(/(us)$/i, "i")
+    gsub!(/(eau)$/i, "eaux")
+    gsub!(/([^saeix])$/i, '\1s')
+
+    self
+  end
+
+  def path_format!
+    replace(self[0..-2]) if self[-1] == "/"
+    replace("/" + self) if self[0] != "/"
+  end
+end