pup 1.0.0

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default:  :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "pup"
+
+# 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,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/pup.rb

@@ -0,0 +1,12 @@
+require "pup/version"
+require "pup/utilities/string"
+require "pup/utilities/object"
+require "pup/utilities/array"
+require "pup/model/model"
+require "pup/routing/router"
+require "pup/controller/base_controller"
+require "pup/application"
+
+module Pup
+  # Your code goes here...
+end

data/lib/pup/application.rb

@@ -0,0 +1,54 @@
+require "rack"
+require "pup/dependencies/request_handler"
+require "pup/dependencies/method_override"
+
+module Pup
+  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
+        pup_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 pup_default_response
+      Rack::Response.new(
+        "<center><b>Pup ::: </b>MVC Framework for web masters</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, :pup_default_response, :page_not_found
+  end
+end

data/lib/pup/controller/base_controller.rb

@@ -0,0 +1,57 @@
+require "active_support/core_ext/hash/indifferent_access"
+require "erubis"
+
+module Pup
+  class BaseController
+    attr_reader :request
+
+    def initialize(request)
+      @request ||= request
+    end
+
+    def get_response
+      @response
+    end
+
+    def render(view_name, locals = {})
+      template = get_template(view_name)
+      parameters = build_view_params(locals)
+      response_body = Erubis::Eruby.new(template).result(parameters)
+      make_response(response_body)
+    end
+
+    def get_template(view_name)
+      filename = File.join(
+        APP_ROOT, "app", "views", controller_name, "#{view_name}.erb"
+      )
+      File.read(filename)
+    end
+
+    def build_view_params(locals)
+      hash = {}
+      vars = instance_variables
+      vars.each { |name| hash[name] = instance_variable_get(name) }
+
+      hash.merge(locals)
+    end
+
+    def make_response(body, status = 200, headers = {})
+      @response = Rack::Response.new(body, status, headers)
+    end
+
+    def params
+      request.params.with_indifferent_access
+    end
+
+    def redirect_to(location)
+      make_response([], 302, "Location" => location)
+    end
+
+    def controller_name
+      self.class.to_s.gsub("Controller", "").to_snakecase
+    end
+
+    private :get_template, :build_view_params, :make_response, :params,
+            :redirect_to, :controller_name
+  end
+end

data/lib/pup/dependencies/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/pup/dependencies/request_handler.rb

@@ -0,0 +1,38 @@
+module Pup
+  class RequestHandler
+    attr_reader :request, :route, :response
+
+    def initialize(request, route)
+      @request = request
+      @route = route
+      process_request
+    end
+
+    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
+
+    private :process_request, :collage_parameters, :controller_response
+  end
+end

data/lib/pup/model/columns_builder.rb

@@ -0,0 +1,41 @@
+module Pup
+  module ColumnsBuilder
+    private
+
+    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 type(value)
+      value.to_s.upcase
+    end
+
+    def primary_key(value)
+      return "PRIMARY KEY" if value
+      ""
+    end
+
+    def nullable(value)
+      return "NOT NULL" unless value
+      "NULL"
+    end
+
+    def default(value)
+      "DEFAULT `#{value}`"
+    end
+
+    def autoincrement(value)
+      "AUTOINCREMENT" if value
+    end
+  end
+end

data/lib/pup/model/model.rb

@@ -0,0 +1,101 @@
+require "sqlite3"
+require "pup/model/columns_builder"
+require "pup/model/orm_methods"
+
+module Pup
+  class Model
+    extend Pup::ColumnsBuilder
+    extend Pup::OrmMethods
+
+    DB ||= SQLite3::Database.new(File.join("db", "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/pup/model/orm_methods.rb

@@ -0,0 +1,56 @@
+module Pup
+  module OrmMethods
+    # columns_array and table_name are defined in the extending
+    # class-model/base
+
+    DB ||= SQLite3::Database.new(File.join("db", "data.sqlite"))
+
+    def create(parameters)
+      model = new
+      parameters.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
+
+    private :row_to_model
+  end
+end

data/lib/pup/routing/route.rb

@@ -0,0 +1,44 @@
+module Pup
+  module Routing
+    class Route
+      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 get_controller_and_action(to)
+        controller, action = to.split("#")
+        controller_name = controller + "_controller"
+        [controller_name, action]
+      end
+
+      def controller
+        Object.const_get(controller_name.to_camelcase)
+      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 :get_controller_and_action
+    end
+  end
+end