panda_frwk 0.1.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 "panda"
+
+# 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/panda.rb

@@ -0,0 +1,47 @@
+require "panda/version"
+require "panda/utils"
+require "panda/record/base"
+require "panda/routing/router"
+require "panda/routing/mapper"
+require "panda/base_controller"
+require "panda/dependencies"
+
+module Panda
+  class Application
+    attr_reader :routes
+
+    def initialize
+      @routes = Routing::Router.new
+    end
+
+    def call(env)
+      return [500, {}, []] if env["PATH_INFO"] == "/favicon.ico"
+      request = Rack::Request.new(env)
+      handler = mapper.perform(request)
+      if handler
+        call_controller_action(request, handler[:target])
+      else
+        process_invalid_request(request)
+      end
+    end
+
+    private
+
+    def call_controller_action(request, target)
+      controller = Object.const_get("#{target[0]}Controller")
+      controller.new(request).dispatch(target[1])
+    end
+
+    def process_invalid_request(request)
+      [
+        404,
+        {},
+        ["Oops! No route for #{request.request_method} #{request.path_info}"]
+      ]
+    end
+
+    def mapper
+      @mapper ||= Routing::Mapper.new(routes.endpoints)
+    end
+  end
+end

data/lib/panda/base_controller.rb

@@ -0,0 +1,68 @@
+require "erb"
+require "tilt"
+
+module Panda
+  class BaseController
+    attr_reader :request
+
+    def initialize(request)
+      @request ||= request
+    end
+
+    def params
+      request.params
+    end
+
+    def redirect_to(location, status: 301)
+      response([], status, "Location" => location)
+    end
+
+    def response(body, status = 200, header = {})
+      @response = Rack::Response.new(body, status, header)
+    end
+
+    def get_response
+      @response
+    end
+
+    def render(*args)
+      response(render_template(*args))
+    end
+
+    def render_template(view_name, locals = {})
+      layout_template, view_template = layout_view_template(view_name)
+      title = view_name.to_s.tr("_", " ")
+      layout_template.render(self, title: title) do
+        view_template.render(self, locals)
+      end
+    end
+
+    def controller_name
+      self.class.to_s.gsub(/Controller$/, "").to_snake_case
+    end
+
+    def dispatch(action)
+      send(action)
+      render(action) unless get_response
+      get_response
+    end
+
+    private
+
+    def layout_view_template(view_name)
+      layout_template = Tilt::ERBTemplate.new(
+        File.join(APP_ROOT, "app", "views", "layouts", "application.html.erb")
+      )
+      view_template = Tilt::ERBTemplate.new(
+        File.join(
+          APP_ROOT,
+          "app",
+          "views",
+          controller_name,
+          "#{view_name}.html.erb"
+        )
+      )
+      [layout_template, view_template]
+    end
+  end
+end

data/lib/panda/dependencies.rb

@@ -0,0 +1,6 @@
+class Object
+  def self.const_missing(const)
+    require const.to_s.to_snake_case
+    Object.const_get(const)
+  end
+end

data/lib/panda/record/base.rb

@@ -0,0 +1,107 @@
+require_relative "database"
+require_relative "base_helper"
+
+module Panda
+  module Record
+    class Base
+      include Record::BaseHelper
+
+      def initialize(attributes = {})
+        attributes.each { |column, value| send("#{column}=", value) }
+      end
+
+      def save
+        query = if id
+                  "UPDATE #{model_table} SET " \
+                  "#{update_placeholders} WHERE id = ?"
+                else
+                  "INSERT INTO #{model_table} (#{current_table_columns})" \
+                  " VALUES (#{current_table_placeholders})"
+                end
+        values = id ? record_values << id : record_values
+        Database.execute_query(query, values)
+        true
+      end
+
+      def update(attributes)
+        attributes.each do |key, value|
+          send("#{key}=", value)
+        end
+        save
+      end
+
+      alias save! save
+
+      def destroy
+        self.class.destroy(id)
+      end
+
+      def self.to_table(name)
+        @table = name.to_s
+      end
+
+      def self.property(column_name, constraints)
+        @properties ||= {}
+        @properties[column_name] = constraints
+      end
+
+      def self.create_table
+        Database.execute_query(
+          "CREATE TABLE IF NOT EXISTS #{table} "  \
+          "(#{column_names_with_constraints.join(', ')})"
+        )
+        build_column_methods
+      end
+
+      def self.create(attributes)
+        model = new(attributes)
+        model.save
+        true
+      end
+
+      def self.all
+        Database.execute_query(
+          "SELECT * FROM #{table} ORDER BY id ASC"
+        ).map(&method(:get_model_object))
+      end
+
+      def self.find(id)
+        row = Database.execute_query(
+          "SELECT * FROM #{table} WHERE id = ?",
+          id.to_i
+        ).first
+        get_model_object(row)
+      end
+
+      def self.find_by(option)
+        row = Database.execute_query(
+          "SELECT * FROM #{table} WHERE #{option.keys.first} = ?",
+          option.values.first
+        ).first
+        get_model_object(row)
+      end
+
+      [%w(last DESC), %w(first ASC)].each do |method_name_and_order|
+        define_singleton_method((method_name_and_order[0]).to_sym) do
+          row = Database.execute_query(
+            "SELECT * FROM #{table} ORDER BY id " \
+            "#{method_name_and_order[1]} LIMIT 1"
+          ).first
+          get_model_object(row) unless row.nil?
+        end
+      end
+
+      def self.count
+        Database.execute_query("SELECT COUNT (*) FROM #{table}")[0][0]
+      end
+
+      def self.destroy(id)
+        Database.execute_query("DELETE FROM #{table} WHERE id = ?", id)
+      end
+
+      def self.destroy_all
+        Database.execute_query "DELETE FROM #{table}"
+      end
+    end
+  end
+end

data/lib/panda/record/base_helper.rb

@@ -0,0 +1,84 @@
+module Panda
+  module Record
+    module BaseHelper
+      def self.included(base)
+        class << base
+          attr_reader :properties, :table
+
+          private
+
+          def column_names_with_constraints
+            name_with_constraints = []
+            properties.each do |column_name, constraints|
+              query_string = []
+              query_string << column_name.to_s
+              parse_constraints(constraints, query_string)
+              name_with_constraints << query_string.join(" ")
+            end
+            name_with_constraints
+          end
+
+          def parse_constraints(constraints, query_string)
+            constraints.each do |attribute, value|
+              query_string << send(attribute.to_s, value)
+            end
+          end
+
+          def build_column_methods
+            properties.keys.each(&method(:attr_accessor))
+          end
+
+          def get_model_object(row)
+            return nil unless row
+            model ||= new
+            properties.keys.each_with_index do |key, index|
+              model.send("#{key}=", row[index])
+            end
+            model
+          end
+
+          def type(value)
+            value.to_s
+          end
+
+          def primary_key(is_primary)
+            "PRIMARY KEY AUTOINCREMENT" if is_primary
+          end
+
+          def nullable(is_null)
+            "NOT NULL" unless is_null
+          end
+        end
+      end
+
+      private
+
+      def model_table
+        self.class.table
+      end
+
+      def current_table_columns
+        columns_without_id.map(&:to_s).join(", ")
+      end
+
+      def current_table_placeholders
+        (["?"] * (self.class.properties.keys.size - 1)).join(", ")
+      end
+
+      def record_values
+        columns_without_id.map(&method(:send))
+      end
+
+      def update_placeholders(columns = self.class.properties.keys)
+        columns.delete(:id)
+        columns.map { |column| "#{column} = ?" }.join(", ")
+      end
+
+      def columns_without_id
+        columns ||= self.class.properties.keys
+        columns.delete(:id)
+        columns
+      end
+    end
+  end
+end

data/lib/panda/record/database.rb

@@ -0,0 +1,15 @@
+require "sqlite3"
+
+module Panda
+  module Record
+    class Database
+      def self.connection
+        @db ||= SQLite3::Database.new(File.join(APP_ROOT, "db", "app.db"))
+      end
+
+      def self.execute_query(*query)
+        connection.execute(*query)
+      end
+    end
+  end
+end

data/lib/panda/routing/mapper.rb

@@ -0,0 +1,34 @@
+module Panda
+  module Routing
+    class Mapper
+      attr_reader :request, :endpoints
+
+      def initialize(endpoints)
+        @endpoints = endpoints
+      end
+
+      def perform(request)
+        @request = request
+        path = request.path_info
+        verb = request.request_method
+
+        endpoints[verb].detect do |endpoint|
+          match_path_with_endpoint(path, endpoint)
+        end
+      end
+
+      private
+
+      def match_path_with_endpoint(path, endpoint)
+        regex, placeholders = endpoint[:pattern]
+        if regex =~ path
+          match_data = $~
+          placeholders.each do |placeholder|
+            request.update_param(placeholder, match_data[placeholder])
+          end
+          return true
+        end
+      end
+    end
+  end
+end

data/lib/panda/routing/router.rb

@@ -0,0 +1,48 @@
+module Panda
+  module Routing
+    class Router
+      attr_reader :endpoints
+
+      def initialize
+        @endpoints ||= Hash.new { |h, k| h[k] = [] }
+      end
+
+      def draw(&block)
+        instance_eval(&block)
+      end
+
+      %w(get post delete put patch).each do |method_name|
+        define_method(method_name) do |path, options|
+          route method_name.upcase, path, options
+        end
+      end
+
+      def root(target) get "/", to: target end
+
+      private
+
+      def route(verb, url, options = {})
+        url = "/#{url}" unless url[0] == "/"
+        @endpoints[verb] << {
+          pattern: match_placeholders(url),
+          path: Regexp.new("^#{url}$"),
+          target: set_controller_action(options[:to])
+        }
+      end
+
+      def match_placeholders(path)
+        placeholders = []
+        path_ = path.gsub(/(:\w+)/) do |match|
+          placeholders << match[1..-1].freeze
+          "(?<#{placeholders.last}>\\w+)"
+        end
+        [/^#{path_}$/, placeholders]
+      end
+
+      def set_controller_action(string)
+        string =~ /^([^#]+)#([^#]+)$/
+        [$1.to_camel_case, $2]
+      end
+    end
+  end
+end