vundabar 0.1.0

data/lib/vundabar/orm/base_model.rb

@@ -0,0 +1,121 @@
+module Vundabar
+  class BaseModel
+    include Vundabar::ModelHelper
+    extend Vundabar::Associations
+    def initialize(attributes = {})
+      attributes.each { |column, value| send("#{column}=", value) }
+    end
+
+    class << self
+      attr_reader :properties
+      private(
+        :make_methods,
+        :build_table_fields,
+        :parse_constraint,
+        :type,
+        :primary_key,
+        :nullable,
+        :get_model_object
+      )
+    end
+
+    def self.to_table(name)
+      @table = name.to_s
+    end
+
+    def self.property(column_name, column_properties)
+      @properties ||= {}
+      @properties[column_name] = column_properties
+    end
+
+    def self.create_table
+      query = "CREATE TABLE IF NOT EXISTS #{table_name} "\
+      "(#{build_table_fields(@properties).join(', ')})"
+      Database.execute_query(query)
+      make_methods
+    end
+
+    def update(attributes)
+      table = self.class.table_name
+      query = "UPDATE #{table} SET #{update_placeholders(attributes)}"\
+      " WHERE id= ?"
+      Database.execute_query(query, update_values(attributes))
+    end
+
+    def destroy
+      table = self.class.table_name
+      Database.execute_query "DELETE FROM #{table} WHERE id= ?", id
+    end
+
+    def save
+      table = self.class.table_name
+      query = if id
+                "UPDATE #{table} SET #{update_placeholders} WHERE id = ?"
+              else
+                "INSERT INTO #{table} (#{table_columns}) VALUES "\
+                "(#{record_placeholders})"
+              end
+      values = id ? record_values << send("id") : record_values
+      Database.execute_query query, values
+    end
+
+    alias save! save
+
+    def self.all
+      query = "SELECT * FROM #{table_name} "\
+        "ORDER BY id DESC"
+      result = Database.execute_query query
+      result.map { |row| get_model_object(row) }
+    end
+
+    def self.create(attributes)
+      model_object = new(attributes)
+      model_object.save
+      id = Database.execute_query "SELECT last_insert_rowid()"
+      model_object.id = id.first.first
+      model_object
+    end
+
+    def self.count
+      result = Database.execute_query "SELECT COUNT(*) FROM #{table_name}"
+      result.first.first
+    end
+
+    [%w(last DESC), %w(first ASC)].each do |method_name_and_order|
+      define_singleton_method((method_name_and_order[0]).to_sym) do
+        query = "SELECT * FROM #{table_name} ORDER BY "\
+        "id #{method_name_and_order[1]} LIMIT 1"
+        row = Database.execute_query query
+        get_model_object(row.first) unless row.empty?
+      end
+    end
+
+    def self.find(id)
+      query = "SELECT * FROM #{table_name} "\
+      "WHERE id= ?"
+      row = Database.execute_query(query, id).first
+      get_model_object(row) if row
+    end
+
+    def self.find_by(option)
+      query = "SELECT * FROM #{table_name} "\
+      "WHERE #{option.keys.first}= ?"
+      row = Database.execute_query(query, option.values.first).first
+      get_model_object(row) if row
+    end
+
+    def self.destroy(id)
+      Database.execute_query "DELETE FROM #{table_name} WHERE id= ?", id
+    end
+
+    def self.destroy_all
+      Database.execute_query "DELETE FROM #{table_name}"
+    end
+
+    def self.where(query_string, value)
+      data = Database.execute_query "SELECT * FROM "\
+      "#{table_name} WHERE #{query_string}", value
+      data.map { |row| get_model_object(row) }
+    end
+  end
+end

data/lib/vundabar/orm/database.rb

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

data/lib/vundabar/orm/model_helper.rb

@@ -0,0 +1,85 @@
+module Vundabar
+  module ModelHelper
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    private
+
+    def table_columns
+      columns = self.class.properties.keys
+      columns.delete(:id)
+      columns.map(&:to_s).join(", ")
+    end
+
+    def update_placeholders(attributes = self.class.properties)
+      columns = attributes.keys
+      columns.delete(:id)
+      columns.map { |column| "#{column}= ?" }.join(", ")
+    end
+
+    def update_values(attributes)
+      attributes.values << id
+    end
+
+    def record_placeholders
+      (["?"] * (self.class.properties.keys.size - 1)).join(",")
+    end
+
+    def record_values
+      column_names = self.class.properties.keys
+      column_names.delete(:id)
+      column_names.map { |column_name| send(column_name) }
+    end
+
+    module ClassMethods
+      def table_name
+        @table
+      end
+
+      def make_methods
+        properties.keys.each do |column_name|
+          attr_accessor column_name
+        end
+      end
+
+      def build_table_fields(properties)
+        all_properties = []
+        properties.each do |field_name, constraints|
+          column = []
+          column << field_name.to_s
+          parse_constraint(constraints, column)
+          all_properties << column.join(" ")
+        end
+        all_properties
+      end
+
+      def parse_constraint(constraints, column)
+        constraints.each do |attribute, value|
+          column << send(attribute.to_s, value)
+        end
+      end
+
+      def type(value)
+        value.to_s
+      end
+
+      def primary_key(value)
+        "PRIMARY KEY AUTOINCREMENT" if value
+      end
+
+      def nullable(value)
+        "NOT NULL" unless value
+      end
+
+      def get_model_object(row)
+        return nil unless row
+        model_name = new
+        properties.keys.each_with_index do |key, index|
+          model_name.send("#{key}=", row[index])
+        end
+        model_name
+      end
+    end
+  end
+end

data/lib/vundabar/orm/validations.rb

@@ -0,0 +1,5 @@
+class Validations
+  def initialize
+    
+  end
+end

data/lib/vundabar/routing/mapper.rb

@@ -0,0 +1,30 @@
+module Vundabar
+  module Routing
+    class Mapper
+      attr_reader :endpoints, :request
+      def initialize(endpoints)
+        @endpoints = endpoints
+      end
+
+      def find_route(request)
+        @request = request
+        path = request.path_info
+        method = request.request_method.downcase.to_sym
+        endpoints[method].detect do |endpoint|
+          match_path_with_endpoint path, endpoint
+        end
+      end
+
+      def match_path_with_endpoint(path, endpoint)
+        regex, placeholders = endpoint[:pattern]
+        if regex =~ path
+          match_data = Regexp.last_match
+          placeholders.each do |placeholder|
+            request.update_param(placeholder, match_data[placeholder])
+          end
+          true
+        end
+      end
+    end
+  end
+end

data/lib/vundabar/routing/route.rb

@@ -0,0 +1,18 @@
+module Vundabar
+  module Routing
+    class Route
+      attr_reader :controller_name, :action, :request
+      def initialize(request, klass_and_method)
+        @request = request
+        @controller_name, @action = klass_and_method
+      end
+
+      def dispatcher
+        controller = controller_name.to_constant.new(request)
+        controller.send(action)
+        controller.render(action) unless controller.get_response
+        controller.get_response
+      end
+    end
+  end
+end

data/lib/vundabar/routing/routing.rb

@@ -0,0 +1,56 @@
+module Vundabar
+  module Routing
+    class Router
+      attr_accessor :endpoints
+      def draw(&block)
+        instance_eval(&block)
+      end
+
+      [:get, :post, :delete, :put, :patch].each do |method|
+        define_method(method) do |path, options|
+          path = "/#{path}" unless path[0] == "/"
+          route_info = {
+            path: path,
+            klass_and_method: controller_and_action(options[:to]),
+            pattern: pattern_for(path)
+          }
+          endpoints[method] << route_info
+        end
+      end
+
+      def root(address)
+        get "/", to: address
+      end
+
+      def resources(args)
+        args = args.to_s
+        get("/#{args}", to: "#{args}#index")
+        get("/#{args}/new", to: "#{args}#new")
+        get("/#{args}/:id", to: "#{args}#show")
+        get("/#{args}/:id/edit", to: "#{args}#edit")
+        delete("/#{args}/:id", to: "#{args}#destroy")
+        post("/#{args}/create", to: "#{args}#create")
+        put("/#{args}/:id", to: "#{args}#update")
+      end
+
+      def pattern_for(path)
+        placeholders = []
+        new_path = path.gsub(/(:\w+)/) do |match|
+          placeholders << match[1..-1]
+          "(?<#{placeholders.last}>[^?/#]+)"
+        end
+        [/^#{new_path}$/, placeholders]
+      end
+
+      def endpoints
+        @endpoints ||= Hash.new { |hash, key| hash[key] = [] }
+      end
+
+      def controller_and_action(to)
+        controller, action = to.split('#')
+        controller = "#{controller.to_camel_case}Controller"
+        [controller, action]
+      end
+    end
+  end
+end

data/lib/vundabar/utilities.rb

@@ -0,0 +1,19 @@
+class String
+  def to_snake_case
+    gsub!(/::/, "/")
+    gsub!(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+    gsub!(/([a-z\d])([A-Z])/, '\1_\2')
+    tr!("-", "_")
+    downcase!
+    self
+  end
+
+  def to_camel_case
+    return self if self !~ /_/ && self =~ /[A-Z]+.*/
+    split("_").map(&:capitalize).join
+  end
+
+  def to_constant
+    Object.const_get(self)
+  end
+end

data/lib/vundabar/version.rb

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

data/lib/vundabar.rb

@@ -0,0 +1,45 @@
+require "vundabar/version"
+require 'active_support/inflector'
+require "vundabar/utilities"
+require "vundabar/dependencies"
+require "vundabar/routing/routing"
+require "vundabar/routing/mapper"
+require "vundabar/routing/route"
+require "vundabar/controller"
+require "pry"
+require "sqlite3"
+require "vundabar/orm/database"
+require "vundabar/orm/model_helper"
+require "vundabar/orm/associations"
+require "vundabar/orm/base_model"
+module Vundabar
+  class Application
+    attr_reader :routes
+    def initialize
+      @routes = Routing::Router.new
+    end
+
+    def call(env)
+      request = Rack::Request.new(env)
+      route = mapper.find_route(request)
+      if route
+        call_controller_and_action(request, route[:klass_and_method])
+      else
+        invalid_route_processor(request)
+      end
+    end
+
+    def mapper
+      @mapper ||= Routing::Mapper.new(routes.endpoints)
+    end
+
+    def call_controller_and_action(request, klass_and_method)
+      Routing::Route.new(request, klass_and_method).dispatcher
+    end
+
+    def invalid_route_processor(request)
+      response = BaseController.new(request).invalid_route(routes.endpoints)
+      [404, {}, [response]]
+    end
+  end
+end

data/vundabar.gemspec

@@ -0,0 +1,44 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "vundabar/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "vundabar"
+  spec.version       = Vundabar::VERSION
+  spec.authors       = ["Eyiowuawi Olalekan"]
+  spec.email         = ["olalekan.eyiowuawi@andela.com"]
+
+  spec.summary       = "A simple rack-based MVC framework"
+  spec.description   = "A simple rack-based MVC framework that can be used to build awesome webapps."
+  spec.homepage      = "https://www.github.com/andela-oeyiowuawi/Vundabar"
+
+  # 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.bindir        = "bin"
+  spec.executables   = ["vundabar"]
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.11"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_runtime_dependency "rack", "~> 1.0"
+  spec.add_runtime_dependency "thor"
+  spec.add_runtime_dependency "activesupport"
+  spec.add_development_dependency "rack-test", "~> 0.6"
+  spec.add_development_dependency "capybara"
+  spec.add_development_dependency "faker"
+  spec.add_development_dependency "selenium-webdriver"
+  spec.add_development_dependency "factory_girl"
+  spec.add_runtime_dependency "pry"
+  spec.add_development_dependency "coveralls"
+  spec.add_runtime_dependency "sqlite3"
+  spec.add_runtime_dependency "tilt"
+end