matrack 0.1.0

data/lib/matrack.rb

@@ -0,0 +1,32 @@
+require_relative "resources"
+
+module Matrack
+  class Application
+    attr_reader :router
+
+    def initialize
+      @router = Router.new
+    end
+
+    def call(env)
+      route = router.route_for(env)
+      if route
+        route.execute(env)
+        response_handler(route)
+      else
+        controller = BaseController.new(env)
+        body = controller.invalid_route
+        [404, {}, [body]]
+      end
+    end
+
+    def response_handler(route)
+      controller = route.mat_controller
+      if controller.response
+        controller.response
+      else
+        controller.render(route.action)
+      end
+    end
+  end
+end

data/lib/matrack/base_controller.rb

@@ -0,0 +1,63 @@
+module Matrack
+  class BaseController
+    include Matrack::HelperTags
+    attr_reader :request, :response
+    attr_accessor :session
+
+    def initialize(env)
+      @request = Rack::Request.new(env)
+      @session = Session.new(env)
+    end
+
+    def params
+      request.params
+    end
+
+    def create_response(body, status = 200, headers = {})
+      @response = Rack::Response.new body, status, headers
+    end
+
+    def render(*args)
+      create_response(render_template(*args))
+    end
+
+    def render_template(view_name, locals = {})
+      template = Tilt::ERBTemplate.new(File.join(APP_PATH, "app", "views",
+                                       "layout", "application.html.erb"))
+      title = view_name.to_s.tr("_", " ").capitalize
+      view = "#{view_name}.html.erb"
+      view_template = Tilt::ERBTemplate.new(File.join(APP_PATH, "app", "views",
+                                                      controller_name, view))
+      template.render(self, title: title) do
+        view_template.render(self, locals.merge!(get_instance_vars))
+      end
+    end
+
+    def invalid_route
+      template = Tilt::ERBTemplate.new(File.join(APP_PATH, "app", "views",
+                                                 "layout", "invalid.html.erb"))
+      template.render(self)
+    end
+
+    def get_instance_vars
+      vars = {}
+      instance_variables.each do |var|
+        key = var.to_s.delete("@").to_sym
+        vars[key] = instance_variable_get(var)
+      end
+      vars
+    end
+
+    def controller_name
+      self.class.to_s.gsub(/Controller$/, "").to_snake_case
+    end
+
+    def authenticate(password)
+      Matrack::DataManager.password_hash(password)
+    end
+
+    def redirect_to(address)
+      create_response([], 302, "location" => address)
+    end
+  end
+end

data/lib/matrack/dependencies.rb

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

data/lib/matrack/helper_tags.rb

@@ -0,0 +1,59 @@
+module Matrack
+  module HelperTags
+
+    def email_validator
+      '[A-Za-z0-9_\-\.]+\@[A-Za-z0-9_\-\.]+\.[A-Za-z]{2,4}'
+    end
+
+    def textbox_tag(name, value = "", class_name = "", holder = "", req = nil,
+                  disabled = nil)
+      tag = "<input type='text' name='#{name}' value='#{value}' "
+      tag += "placeholder='#{holder}' class='#{class_name}'"
+      tag += "required='#{req}'" unless req.nil?
+      tag += disabled.nil? ? ">" : " disabled='#{disabled}'>"
+    end
+
+    def password_tag(name, class_name = "", holder = "", req = nil,
+                     disabled = nil)
+      tag = "<input type='password' name='#{name}' "
+      tag += "placeholder='#{holder}' class='#{class_name}'"
+      tag += "required='#{req}'" unless req.nil?
+      tag += disabled.nil? ? ">" : " disabled='#{disabled}'>"
+    end
+
+    def emailbox_tag(name, value = "", class_name = "", holder = "", req = nil,
+                   disabled = nil, pattern = nil)
+      tag = "<input type='email' name='#{name}' value='#{value}' "
+      tag += "placeholder='#{holder}' class='#{class_name}'"
+      tag += "required='#{req}'" unless req.nil?
+      regex_pattern = pattern.nil? ? "#{email_validator}" : "#{pattern}"
+      tag += " pattern='#{regex_pattern}'"
+      tag += disabled.nil? ? ">" : " disabled='#{disabled}'>"
+    end
+
+    def submit_tag(name, value = "Submit", class_name = "")
+      tag = "<input type='submit' name='#{name}' value='#{value}' "
+      tag += "class='#{class_name}'>"
+    end
+
+    def link_tag(ref, class_name = "", title = "Link")
+      "<a href='#{ref}' class='#{class_name}'>#{title}</a>"
+    end
+
+    def image_tag(name, alt = "image")
+      "<img src='../../images/#{name}' alt= '#{alt}'>"
+    end
+
+    def include_stylesheet(name)
+      "<link href='../../css/#{name}.css' rel='stylesheet' type= 'text/css'>"
+    end
+
+    def include_javascript(name)
+      "<script src='../../js/#{name}.js' type='text/javascript'></script>"
+    end
+
+    def display_favicon
+      "<link rel='icon' type='image/png' href='../../images/favicon.png' />"
+    end
+  end
+end

data/lib/matrack/route.rb

@@ -0,0 +1,15 @@
+class Route
+  attr_reader :matclass, :action, :mat_controller
+
+  def initialize(route_info)
+    matklass = route_info.last[:matclass].to_camel_case
+    @matclass = Object.const_get(matklass+"Controller")
+    @path = route_info.first
+    @action = route_info.last[:method].to_sym
+  end
+
+  def execute(env)
+    @mat_controller = matclass.new(env)
+    @mat_controller.send(action)
+  end
+end

data/lib/matrack/router.rb

@@ -0,0 +1,42 @@
+class Router
+  attr_reader :routes
+
+  def initialize
+    @routes = Hash.new { |hash, key| hash[key] = [] }
+  end
+
+  def draw(&block)
+    instance_eval(&block)
+  end
+
+  def root(root_path)
+    get "/", root_path
+  end
+
+  %w(get post put delete).each do |request_type|
+    define_method(request_type) do | path, options|
+      request_type = request_type.to_sym
+      if options.is_a? Hash
+        @routes[request_type] << [path, case_parser(options[:to])]
+      else
+        @routes[request_type] << [path, case_parser(options)]
+      end
+    end
+  end
+
+  def route_for(env)
+    path = env["PATH_INFO"]
+    verb = env["REQUEST_METHOD"].downcase.to_sym
+    route_info = routes[verb].detect do |route|
+      route.first == path || route.first == path.sub("/", "")
+    end
+    Route.new(route_info) if route_info
+  end
+
+  private
+
+  def case_parser(str)
+    matclass, method = str.split("#")
+    { matclass: matclass.to_camel_case, method: method.to_snake_case }
+  end
+end

data/lib/matrack/session.rb

@@ -0,0 +1,21 @@
+module Matrack
+  class Session
+    attr_accessor :request
+
+    def initialize(env)
+      @request = Rack::Request.new(env)
+    end
+
+    def [](key)
+      request.session[key.to_sym]
+    end
+
+    def []=(key, value)
+      request.session[key.to_sym] = value
+    end
+
+    def clear
+      request.session.clear
+    end
+  end
+end

data/lib/matrack/utility.rb

@@ -0,0 +1,33 @@
+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
+  end
+
+  def to_camel_case
+    return self if self !~ /_/ && self =~ /[A-Z]+.*/
+    split("_").map(&:capitalize).join
+  end
+
+  def to_b
+    return true if !self.nil? && (self == true || downcase == "true")
+    return false if self.nil? || downcase == "false" || self == false
+    false
+  end
+
+  def titleize
+    split.map!(&:capitalize).join(" ")
+  end
+
+  def pluralize
+    self + "s" unless self.end_with? "s"
+  end
+
+end
+
+class ::Array
+  def hash_getter
+    first.select{|k| k.is_a? String}
+  end
+end

data/lib/matrack/version.rb

@@ -0,0 +1,3 @@
+module Matrack
+  VERSION = "0.1.0"
+end

data/lib/orm/base_model.rb

@@ -0,0 +1,57 @@
+module Matrack
+  class BaseModel < Queries
+    def initialize(hash = {})
+      hash.each_pair { |k,v| send("#{k}=", v) }
+      self
+    end
+
+    @@query_string = ""
+
+    class << self
+
+      def create_table
+        query_string = @@query_string.sub(/,[\s]$/,"")
+        create_table_fields(table_name,query_string)
+        @@query_string = ""
+      end
+
+      def property(name, type = "str", desc = {} )
+        field_hash = { name => type }
+        if verify_col_type(field_hash) == true
+          db_str = DataUtility.type_mapper(field_hash)
+          @@query_string += query_builder(db_str.keys, db_str.values,                              desc)
+          @@query_string += ", " unless @@query_string == ""
+          get_and_set_property(name)
+        else
+          puts db_error(verify_col_type(field_hash))
+          exit
+        end
+      end
+
+      def get_and_set_property(name)
+        define_method(name) do
+         instance_variable_get("@#{name}")
+        end
+        define_method("#{name}=") do |value|
+          instance_variable_set("@#{name}", "#{value}")
+        end
+      end
+
+      def create(field_hash)
+        passwordify(field_hash)
+        attributes = "#{field_hash.keys}".gsub(/:/, "").gsub(/\[|\]/,"")
+        values = "#{field_hash.values}".gsub(/\[|\]/,"").gsub(/\"/,"'")
+        db_conn.execute "INSERT INTO #{table_name} (#{attributes}) VALUES (#{
+          values});"
+      end
+
+      def passwordify(field_hash)
+        if field_hash.keys.include? :password
+          hashed_pass = password_hash(field_hash[:password])
+          field_hash[:password] = hashed_pass
+        end
+        field_hash
+      end
+    end
+  end
+end

data/lib/orm/data_manager.rb

@@ -0,0 +1,57 @@
+require "sqlite3"
+require "digest/sha1"
+
+module Matrack
+  class DataManager
+
+    class << self
+      def db_conn
+        db = SQLite3::Database.new "#{APP_PATH}/db/app.sqlite3"
+        db.results_as_hash = true
+        db
+      end
+
+      def db_error(message)
+        DataUtility.db_error(message)
+      end
+
+      def query_builder(name, type, desc)
+        name = name.join
+        type = type.join
+        primary_key = "PRIMARY KEY" if desc[:primary_key] == true
+        primary_key += " AUTOINCREMENT" if desc[:primary_key] == true &&
+                                           type == "INTEGER"
+        primary_key = primary_key ? primary_key : ""
+        null_value = desc[:nullable].nil? ? "NULL" : "NOT NULL"
+        null_value = "NOT NULL" if desc[:primary_key] == true
+        "#{name} #{type} #{primary_key} #{null_value}"
+      end
+
+      def allowed_field_types
+        ["int", "str", "time", "date"]
+      end
+
+      def create_table_fields(table_name, qry_str)
+        begin
+          db_conn.execute "CREATE TABLE IF NOT EXISTS #{table_name} (#{qry_str});"
+        rescue
+          puts db_error("Can not create table")
+          exit
+        end
+      end
+
+      def verify_col_type(field_hash)
+        return true if valid_col_types?(field_hash)
+        "Invalid column type(s) specified"
+      end
+
+      def valid_col_types?(field_hash)
+        field_hash.values.all? { |val| allowed_field_types.include? val.to_s }
+      end
+
+      def password_hash(password)
+        Digest::SHA1.hexdigest(password)
+      end
+    end
+  end
+end

data/lib/orm/data_utility.rb

@@ -0,0 +1,33 @@
+class DataUtility
+  class << self
+    def type_mapper(field_hash)
+      db_data = {}
+      field_hash.each_pair do |k, v|
+        v = v.to_s
+        if v == "str" || v == "time" ||  v == "date"
+          db_data[k] = "VARCHAR"
+        elsif v == "int"
+          db_data[k] = "INTEGER"
+        end
+      end
+      db_data
+    end
+
+    def create_table_query(db_data)
+      db_str = ""
+      db_data.each_pair do |k,v|
+        db_str +=" " + "#{k}" + " " + "#{v}"
+        db_str += "," unless k == db_data.keys.last
+      end
+      db_str
+    end
+
+    def db_error(message)
+      <<-EOS
+            *************************************************
+                DB ERROR - #{message.to_s.titleize}
+            *************************************************
+      EOS
+    end
+  end
+end

data/lib/orm/fetch_queries.rb

@@ -0,0 +1,53 @@
+module Matrack
+  class FetchQueries < DataManager
+    class << self
+      def table_name
+        self.to_s.to_snake_case + "s"
+      end
+
+      def uniq_id
+        "#{self.to_s.to_snake_case}_id"
+      end
+
+      def execute(query)
+        objs = []
+        rows = db_conn.execute query
+        rows.each{|row| objs << self.new(row.reject!{ |k| !k.is_a? String }) }
+        objs
+      end
+
+      def all
+        execute "SELECT * FROM #{table_name}"
+      end
+
+      def find(id)
+        execute("SELECT * FROM #{table_name} WHERE (#{uniq_id} = #{id})").first
+      end
+
+      def last
+        offset = count - 1
+        execute("SELECT * FROM #{table_name} LIMIT(1) OFFSET(#{offset})").first
+      end
+
+      def limit(num)
+        execute "SELECT * FROM #{table_name} LIMIT(#{num})"
+      end
+
+      def first
+        execute("SELECT * FROM #{table_name} LIMIT(1)").first
+      end
+
+      def find_by(col, val)
+        execute("SELECT * FROM #{table_name} WHERE (#{col} = '#{val}')
+                LIMIT 1").first
+      end
+
+      # firstname: "name", lastname: "last"
+      def find_cols(col_hash)
+        clause = col_hash.map{|k,v| "#{k.to_s} = " "'#{v}'"}.join(" AND ")
+        execute("SELECT * FROM #{table_name} WHERE (#{clause})
+                LIMIT 1").first
+      end
+    end
+  end
+end