hemp 1.0.1

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+
+task default: :test
+task :test do
+  Dir.glob("./test/*/*_test.rb").each { |file| require file }
+end

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "hemp"
+
+# 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/hemp.gemspec

@@ -0,0 +1,45 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "hemp/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "hemp"
+  spec.version       = Hemp::VERSION
+  spec.authors       = ["Tobi Oduah"]
+  spec.email         = ["tobi.oduah@andela.com"]
+
+  spec.summary       = "Simple web framework for building web apps in Ruby "\
+                        "following the MVC design pattern"
+  spec.description   = "Simple web framework for building web apps in Ruby "\
+                        "following the MVC design pattern"
+  spec.homepage      = "https://github.com/andela-toduah/hemp-web-framework"
+  spec.license       = "MIT"
+
+  # 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 do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "bundler", "~> 1.10"
+  spec.add_dependency "rake", "~> 10.0"
+  spec.add_dependency "rack"
+  spec.add_dependency "rack-test"
+  spec.add_dependency "facets"
+  spec.add_dependency "minitest"
+  spec.add_dependency "erubis"
+  spec.add_dependency "tilt"
+  spec.add_dependency "sqlite3"
+  spec.add_dependency "codeclimate-test-reporter"
+end

data/lib/hemp.rb

@@ -0,0 +1,5 @@
+require "hemp/version"
+require "hemp/application"
+require "hemp/controller"
+require "hemp/base_record"
+require "hemp/dependencies"

data/lib/hemp/aliases.rb

@@ -0,0 +1,13 @@
+require "hemp/routing/route"
+require "hemp/routing/route_syntax_error"
+require "hemp/routing/route_extensions"
+require "hemp/routing/route_split"
+
+module Hemp
+  module Aliases
+    RouteAlias = Hemp::Routing::Route
+    RouteError = Hemp::Routing::RouteSyntaxError
+    RouteSplitter = Hemp::Routing::RouteSplitter
+    RouteExtensions = Hemp::Routing::RouteExtensions
+  end
+end

data/lib/hemp/application.rb

@@ -0,0 +1,59 @@
+require "hemp/extensions/object"
+require "hemp/extensions/hash"
+require "hemp/routing/base"
+require "rack"
+
+module Hemp
+  class Application
+    attr_reader :pot, :request, :params
+
+    def initialize
+      @pot = Hemp::Routing::Base.new
+    end
+
+    def call(env)
+      @request = Rack::Request.new(env)
+      route = find_route(request) unless env.empty?
+      route ? process_request(route) : send_default_response
+    end
+
+    def find_route(request)
+      verb = request.request_method.downcase.to_sym
+      route = @pot.routes[verb].detect do|route_val|
+        route_val == request.path_info
+      end
+
+      route
+    end
+
+    def process_request(route)
+      controller_class = Object.
+                         const_get(route.controller_camel).new
+      set_request_and_params_as_instance route, controller_class
+      obtain_appropriate_response(controller_class, route)
+    end
+
+    def get_params(route)
+      request.params.merge(route.get_url_vars(request.path_info))
+    rescue RuntimeError
+      {}.merge(route.get_url_vars(request.path_info))
+    end
+
+    def set_request_and_params_as_instance(route, controller_class)
+      params = get_params(route)
+      request.instance_variable_set "@params", params
+      controller_class.instance_variable_set "@request", request
+    end
+
+    def obtain_appropriate_response(controller_class, route)
+      controller_class.send(route.action_sym)
+      response = controller_class.response
+
+      response ? response : controller_class.render(route.action_sym)
+    end
+
+    def send_default_response
+      Rack::Response.new "Hello from Hemp", 200, {}
+    end
+  end
+end

data/lib/hemp/base_record.rb

@@ -0,0 +1,96 @@
+require "sqlite3"
+require "hemp/orm/database_error"
+require "hemp/orm/property"
+require "hemp/orm/sql_helper"
+require "hemp/orm/record_interface"
+require "hemp/orm/class_instance_vars"
+
+module Hemp
+  class BaseRecord < Hemp::Orm::RecordInterface
+    include Hemp::Orm::ClassInstanceVars
+
+    def initialize(hash_arg = {})
+      self.class.expose_instance_vars
+      return super() if hash_arg.empty?
+      save_model_attributes hash_arg
+    end
+
+    def save_model_attributes(hash_arg)
+      row = []
+      properties.map do |property|
+        row << hash_arg.values_at(property.name)
+      end
+
+      self.class.set_instance_vars(self, row.flatten)
+    end
+
+    def save
+      row = self.class.find id
+      return update if row
+      SqlHelper.execute get_save_query
+      set_id_value
+    rescue SQLite3::ConstraintException
+      false
+    end
+
+    def set_id_value
+      id = SqlHelper.execute("select last_insert_rowid() "\
+        "from #{table_name}").first.first
+      instance_variable_set "@id", id
+    end
+
+    def update
+      SqlHelper.execute get_update_query
+    rescue SQLite3::ConstraintException
+      false
+    end
+
+    def destroy
+      self.class.destroy id
+    end
+
+    def get_save_query
+      sql_values = stringify_values.join(", ")
+
+      "insert into #{table_name} (#{sql_properties})"\
+        " values (#{sql_values})"
+    end
+
+    def get_update_query
+      sql_update_properties = get_update_values.join(", ")
+
+      "update #{table_name} set #{sql_update_properties}"\
+        " where id = #{id}"
+    end
+
+    def get_values
+      values = []
+      internal_props.each do |column|
+        values << (instance_variable_get("@#{column}") || "NULL")
+      end
+
+      values
+    end
+
+    def stringify_values
+      get_values.map do |val|
+        (val == "NULL") || (val == "") ? "NULL" : %('#{val}')
+      end
+    end
+
+    def get_update_values
+      all_update_properties = []
+      stringify_values.each_with_index do |value, index|
+        all_update_properties << (internal_props[index].to_s + " = " + value)
+      end
+
+      all_update_properties
+    end
+
+    def ==(other)
+      instance_variables.each do |var|
+        instance_variable_get(var) == other.instance_variable_get(var)
+      end
+    end
+  end
+end

data/lib/hemp/controller.rb

@@ -0,0 +1,54 @@
+require "tilt/erubis"
+require "tilt"
+require "facets"
+require "ostruct"
+require "rack"
+
+module Hemp
+  class BaseController
+    attr_reader :response, :request
+
+    def render(action, instance_vars = get_instance_vars)
+      controller_folder = self.class.name.pathize.split("_").first
+      tilt_template = get_tilt_template(controller_folder, action)
+      instance_vars.delete_field :request
+      set_response(tilt_template.render(instance_vars))
+    end
+
+    def get_tilt_template(controller_folder, action)
+      template_file = File.join(
+        RACK_ROOT, "app", "views", controller_folder, "#{action}.html.erb"
+      )
+
+      Tilt.new template_file
+    end
+
+    def get_instance_vars
+      vars = instance_variables
+      instance_vars = {}
+
+      OpenStruct.new(pile_up_instance_vars(vars, instance_vars))
+    end
+
+    def pile_up_instance_vars(vars, instance_vars)
+      vars.each do |var|
+        trimmed_var = var[1..-1]
+        instance_vars[trimmed_var] = instance_variable_get "@#{trimmed_var}"
+      end
+
+      instance_vars
+    end
+
+    def redirect_to(location)
+      set_response [], 302, "Location" => location
+    end
+
+    def set_response(body, status = 200, headers = {})
+      @response = Rack::Response.new(body, status, headers)
+    end
+
+    def params
+      @params ||= OpenStruct.new(request.params)
+    end
+  end
+end

data/lib/hemp/dependencies.rb

@@ -0,0 +1,10 @@
+module Hemp
+  module Dependencies
+    def self.load_files
+      $LOAD_PATH.unshift(File.join(RACK_ROOT, "app", "controllers"))
+      $LOAD_PATH.unshift(File.join(RACK_ROOT, "app", "models"))
+      Dir["#{RACK_ROOT}/app/controllers/*"].each { |file| load file }
+      Dir["#{RACK_ROOT}/app/models/*"].each { |file| load file }
+    end
+  end
+end

data/lib/hemp/extensions/hash.rb

@@ -0,0 +1,10 @@
+class Hash
+  def slice(*args)
+    sliced_value = {}
+    args.each do |arg|
+      sliced_value[arg] = fetch(arg)
+    end
+
+    sliced_value
+  end
+end

data/lib/hemp/extensions/object.rb

@@ -0,0 +1,9 @@
+require "facets"
+
+class Object
+  def self.const_missing(const_name)
+    require const_name.to_s.pathize
+    Object.const_get const_name
+  rescue LoadError
+  end
+end

data/lib/hemp/orm/class_instance_vars.rb

@@ -0,0 +1,21 @@
+module Hemp
+  module Orm
+    module ClassInstanceVars
+      def properties
+        self.class.properties
+      end
+
+      def internal_props
+        self.class.internal_props
+      end
+
+      def sql_properties
+        self.class.sql_properties
+      end
+
+      def table_name
+        self.class.table_name
+      end
+    end
+  end
+end

data/lib/hemp/orm/database_error.rb

@@ -0,0 +1,10 @@
+module Hemp
+  module Orm
+    class DatabaseError < StandardError
+      def initialize(custom_message = "")
+        super "Error while creating database. "\
+        "#{custom_message}"
+      end
+    end
+  end
+end

data/lib/hemp/orm/property.rb

@@ -0,0 +1,49 @@
+module Hemp
+  module Orm
+    class Property
+      attr_reader :name, :options, :type, :primary_key, :nullable
+      def initialize(name, options = {})
+        @name = name
+        @options = options
+        parse_options
+      end
+
+      def parse_options
+        set_default_options
+        @options.each_pair do |key, value|
+          case key
+          when :type
+            instance_variable_set("@type", value) if supported_type? value
+          when :primary_key, :nullable
+            instance_variable_set "@#{key}", value
+          end
+        end
+      end
+
+      def set_default_options
+        @type = "text"
+        @primary_key = false
+        @nullable = true
+      end
+
+      def to_s
+        "#{name} #{type}" <<
+          (nullable ? "" : " not null") <<
+          (primary_key ? " primary key" : "") <<
+          (primary_key && type == :integer ? " autoincrement" : "")
+      end
+
+      def supported_type?(arg)
+        if %w(boolean integer text).include? arg.to_s
+          true
+        else
+          raise DatabaseError.new "Type parameter passed in not supported."
+        end
+      end
+
+      def ==(other)
+        name == other.name
+      end
+    end
+  end
+end

data/lib/hemp/orm/record_interface.rb

@@ -0,0 +1,99 @@
+module Hemp
+  module Orm
+    class RecordInterface
+      SqlHelper = Hemp::Orm::SqlHelper
+
+      class << self
+        attr_accessor :table_name, :properties,
+                      :internal_props, :sql_properties
+
+        def to_table(name)
+          @table_name = name
+          property :id, type: :integer, primary_key: true
+        end
+
+        def create(hash_arg)
+          new_model = const_get(name).new(hash_arg)
+
+          new_model.save ? new_model : false
+        end
+
+        def property(name, options)
+          @properties ||= []
+          new_property = Property.new(name, options)
+          @properties << new_property unless @properties.include? new_property
+        rescue DatabaseError => e
+          puts e.message
+          exit
+        end
+
+        def get_properties
+          props = @properties.map(&:name)
+          props.delete :id
+
+          props
+        end
+
+        def create_table
+          SqlHelper.execute "create table if not exists "\
+          "#{@table_name} (#{@properties.join(', ')})"
+
+          construct_sql_properties
+          expose_instance_vars
+        end
+
+        def construct_sql_properties
+          @internal_props = get_properties
+          @sql_properties = @internal_props.join(", ")
+        end
+
+        def expose_instance_vars
+          @properties.map(&:name).each do |name|
+            const_get(self.name).class_eval { attr_accessor name.to_sym }
+          end
+        end
+
+        def set_instance_vars(scope, row)
+          @properties.map(&:name).each_with_index do |name, index|
+            scope.instance_variable_set "@#{name}", row[index]
+          end
+        end
+
+        def initialize_model(row)
+          model = const_get(name).new
+          set_instance_vars model, row
+
+          model
+        end
+
+        def find(id)
+          row = SqlHelper.execute "select * from #{@table_name} "\
+          "where id = ?", [id]
+
+          return initialize_model(row.first) unless row.empty?
+          nil
+        end
+
+        def count
+          row = SqlHelper.execute "select count(*) from #{@table_name}"
+
+          row.first.first
+        end
+
+        def all
+          rows = SqlHelper.execute "select * from #{@table_name}"
+          rows.map { |row| initialize_model row }
+        end
+
+        def destroy(id)
+          SqlHelper.execute "delete from #{@table_name} "\
+          "where id = ?", [id]
+        end
+
+        def destroy_all
+          SqlHelper.execute "delete from #{@table_name}"
+        end
+      end
+    end
+  end
+end