ru.Bee 1.1.0

data/lib/rubee/controllers/extensions/auth_tokenable.rb

@@ -0,0 +1,81 @@
+require_relative File.join(__dir__, 'middlewarable')
+require 'date'
+
+module Rubee
+  module AuthTokenable
+    KEY = "secret#{Date.today}".freeze # Feel free to cusomtize it
+    EXPIRE = 3600 # 1 hour
+
+    def self.included(base)
+      base.include(Middlewarable)
+      base.include(InstanceMethods)
+      base.extend(ClassMethods)
+
+      base.attach('AuthTokenMiddleware')
+    end
+
+    module InstanceMethods
+      def authentificated?
+        methods = self.class._auth_methods
+        return true if methods && !methods.include?(@route[:action].to_sym)
+        # This is suppose to be set in the middleware, otherwise it will return false
+        valid_token?
+      end
+
+      def valid_token?
+        @request.env["rack.session"]&.[]("authentificated")
+      end
+
+      def authentificated_user
+        # User model must be created with email and password properties at least
+        @authehtificated_user ||= User.where(email: params[:email], password: params[:password]).first
+      end
+
+      def authentificate!
+        return false unless authentificated_user
+        # Generate token
+        payload = { username: params[:email], exp: Time.now.to_i + EXPIRE }
+        @token = JWT.encode(payload, KEY, 'HS256')
+        # Set jwt token to the browser within cookie, so next browser request will include it.
+        # make sure it passed to response_with headers options
+        @token_header = { "set-cookie" => "jwt=#{@token}; path=/; httponly; secure" }
+
+        true
+      end
+
+      def unauthentificate!
+        @request.env["rack.session"]["authentificated"] = nil if @request.env["rack.session"]&.[]("authentificated")
+        @authehtificated_user = nil if @authehtificated_user
+        @zeroed_token_header = {
+          "set-cookie" => "jwt=; path=/; httponly; secure; expires=thu, 01 jan 1970 00:00:00 gmt",
+          "content-type" => "application/json"
+        }
+
+        true
+      end
+
+      def handle_auth
+        if authentificated?
+          yield
+        else
+          response_with type: :unauthentificated
+        end
+      end
+    end
+
+    module ClassMethods
+      def auth_methods(*args)
+        @auth_methods ||= []
+        @auth_methods.concat(args.map(&:to_sym)).uniq!
+
+        @auth_methods.each do |method|
+          around method, :handle_auth
+        end
+      end
+
+      def _auth_methods
+        @auth_methods || []
+      end
+    end
+  end
+end

data/lib/rubee/controllers/extensions/middlewarable.rb

@@ -0,0 +1,31 @@
+# Rubee system file
+# WARNING: DO NOT EDIT THIS FILE UNLESS YOU FEEL STRONG DESIRE
+# Unpreditable behaviour may happen. Take it as your own risk.
+module Middlewarable
+  def self.included(base)
+    base.extend(ClassMethods)
+    base.prepend(Initializer)
+  end
+
+  module Initializer
+    def initialize(req, route)
+      app = ->(env) { super(req, route) }
+      self.class.middlewares.reverse_each do |middleware|
+        middleware_class = Object.const_get(middleware)
+        app = middleware_class.new(app, req)
+      end
+      app.call(req.env)
+    end
+  end
+
+  module ClassMethods
+    def attach(*args)
+      @middlewares ||= []
+      @middlewares.concat(args).uniq
+    end
+
+    def middlewares
+      @middlewares || []
+    end
+  end
+end

data/lib/rubee/controllers/middlewares/auth_token_middleware.rb

@@ -0,0 +1,42 @@
+module Rubee
+  class AuthTokenMiddleware
+    def initialize(app, req)
+      @req = req
+      @app = app
+    end
+
+    def call(env)
+      # get token from header
+      auth_header = headers(env)["HTTP_AUTHORIZATION"]
+      token = auth_header ? auth_header[/^Bearer (.*)$/]&.gsub("Bearer ", "") : nil
+      # get token from cookies
+      token = @req.cookies["jwt"] unless token
+      if valid_token?(token)
+        env["rack.session"] ||= {}
+        env["rack.session"]["authentificated"] = true
+      end
+
+      @app.call(env)
+    end
+
+    private
+
+    def headers(env)
+      env.each_with_object({}) { |(k, v), h| h[k] = v if k.start_with?("HTTP_") }
+    end
+
+    def valid_token?(token)
+      return false unless token
+
+      hash = decode_jwt(token)
+      email = hash[:username]
+
+      User.where(email:)&.any? if email
+    end
+
+    def decode_jwt(token)
+      decoded_array = JWT.decode(token, AuthTokenable::KEY, true, { algorithm: 'HS256' }) rescue decoded_array = []
+      decoded_array&.first&.transform_keys(&:to_sym) || {}  # Extract payload
+    end
+  end
+end

data/lib/rubee/extensions/hookable.rb

@@ -0,0 +1,85 @@
+module Rubee
+  module Hookable
+    def self.included(base)
+      base.extend(ClassMethods)
+      base.include(InstanceMethods)
+    end
+
+    module ClassMethods
+      def before(method, handler, **options)
+        hooks = Module.new do
+          define_method(method) do |*args, &block|
+            if conditions_met?(options[:if], options[:unless])
+              handler.respond_to?(:call) ? handler.call : send(handler)
+            end
+
+            super(*args, &block)
+          end
+        end
+        prepend hooks
+      end
+
+      def after(method, handler, **options)
+        hooks = Module.new do
+          define_method(method) do |*args, &block|
+            result = super(*args, &block)
+
+            if conditions_met?(options[:if], options[:unless])
+              handler.respond_to?(:call) ? handler.call : send(handler)
+            end
+
+            result
+          end
+        end
+        prepend hooks
+      end
+
+      def around(method, handler, **options)
+        hooks = Module.new do
+          define_method(method) do |*args, &block|
+            if conditions_met?(options[:if], options[:unless])
+              if handler.respond_to?(:call)
+                handler.call { super(*args, &block) }
+              else
+                send(handler) { super(*args, &block) }
+              end
+            else
+              super(*args, &block)
+            end
+          end
+        end
+        prepend hooks
+      end
+    end
+
+    module InstanceMethods
+      private
+
+      def conditions_met?(if_condition = nil, unless_condition = nil)
+        return true if if_condition.nil? && unless_condition.nil?
+
+        if_condition_result = true
+        if_condition_result =
+          if if_condition.nil?
+            true
+          elsif if_condition.respond_to?(:call)
+            if_condition.call
+          elsif respond_to?(if_condition)
+            send(if_condition)
+          end
+
+        unless_condition_result = true
+        unless_condition_result =
+          if unless_condition.nil?
+            false
+          elsif unless_condition.respond_to?(:call)
+            unless_condition.call
+          elsif respond_to?(unless_condition)
+            send(unless_condition)
+          end
+
+        if_condition_result && !unless_condition_result
+      end
+    end
+  end
+end

data/lib/rubee/extensions/serializable.rb

@@ -0,0 +1,28 @@
+module Rubee
+  module Serializable
+    def self.included(base)
+      base.send(:include, InstanceMethods)
+      base.prepend(Initializer)
+    end
+
+    module Initializer
+      def initialize(attrs)
+        attrs.each do |attr, value|
+          self.send("#{attr}=", value)
+        end
+      end
+    end
+
+    module InstanceMethods
+      def to_json
+        to_h.to_json
+      end
+
+      def to_h
+        instance_variables.each_with_object({}) do |var, hash|
+          hash[var.to_s.delete("@")] = instance_variable_get(var)
+        end
+      end
+    end
+  end
+end

data/lib/rubee/models/database_object.rb

@@ -0,0 +1,50 @@
+module Rubee
+  class DatabaseObject
+    include Serializable
+    include Hookable
+
+    def destroy
+    end
+
+    def save
+    end
+
+    def update(args = {})
+    end
+
+    def reload
+    end
+
+    class << self
+      def last
+      end
+
+      def connection
+      end
+
+      def all
+      end
+
+      def find(id)
+      end
+
+      def where(args)
+      end
+
+      def create(attrs)
+      end
+
+      def pluralize_class_name
+        word = self.name.downcase
+          # Basic pluralization rules
+        if word.end_with?('y') && !%w[a e i o u].include?(word[-2])
+          word[0..-2] + 'ies' # Replace "y" with "ies"
+        elsif word.end_with?('s', 'x', 'z', 'ch', 'sh')
+          word + 'es' # Add "es" for certain endings
+        else
+          word + 's' # Default to adding "s"
+        end
+      end
+    end
+  end
+end

data/lib/rubee/models/sequel_object.rb

@@ -0,0 +1,86 @@
+module Rubee
+  class SequelObject < DatabaseObject
+    DB = Sequel.connect(Rubee::Configuration.get_database_url) rescue nil
+
+    def destroy
+      self.class.connection.where(id:).delete
+    end
+
+    def save
+      args = to_h.dup&.transform_keys(&:to_sym)
+      if args[:id]
+        udpate(args) rescue return false
+
+        true
+      else
+        created_object = self.class.create(args) rescue return false
+        self.id = created_object.id
+
+        true
+      end
+    end
+
+    def assign_attributes(args={})
+      to_h.each do |attr, value|
+        self.send("#{attr}=", args[attr.to_sym]) if args[attr.to_sym]
+      end
+    end
+
+    def update(args = {})
+      assign_attributes(args)
+      found_hash = self.class.connection.where(id:)
+      return self.class.find(id) if found_hash&.update(**args)
+
+      false
+    end
+
+    def persisted?
+      !!id
+    end
+
+    def reload
+      self.class.find(id)
+    end
+
+    class << self
+      def last
+        found_hash = connection.order(:id).last
+        return self.new(**found_hash) if found_hash
+
+        nil
+      end
+
+      def connection
+        @connection ||= DB[pluralize_class_name.to_sym]
+      end
+
+      def all
+        connection.map do |record_hash|
+          self.new(**record_hash)
+        end
+      end
+
+      def find(id)
+        found_hash = connection.where(id:)&.first
+        return self.new(**found_hash) if found_hash
+
+        nil
+      end
+
+      def where(args)
+        connection.where(**args).map do |record_hash|
+          self.new(**record_hash)
+        end
+      end
+
+      def create(attrs)
+        out_id = connection.insert(**attrs)
+        self.new(**(attrs.merge(id: out_id)))
+      end
+
+      def destroy_all
+        all.each(&:destroy)
+      end
+    end
+  end
+end

data/lib/rubee/tests/auth_tokenable_test.rb

@@ -0,0 +1,29 @@
+require_relative 'test_helper'
+
+class RubeeAppTest < Minitest::Test
+  include Rack::Test::Methods
+
+  def app
+    Rubee::Application.instance
+  end
+
+  def setup
+    Rubee::Autoload.call
+  end
+
+  def teardown
+    # detach auth methods
+     if WelcomeController.instance_variable_defined?(:@auth_methods)
+       WelcomeController.send(:remove_instance_variable, :@auth_methods)
+     end
+  end
+
+  def test_welcome_controller_included_auth_tokenable
+    WelcomeController.include(AuthTokenable)
+    WelcomeController.auth_methods :show
+
+    get '/'
+
+    assert_equal last_response.status, 401
+  end
+end

data/lib/rubee/tests/rubeeapp_test.rb

@@ -0,0 +1,24 @@
+require_relative 'test_helper'
+
+class RubeeAppTest < Minitest::Test
+  include Rack::Test::Methods
+
+  def app
+    Rubee::Application.instance
+  end
+
+
+  def test_welcome_route
+    get '/'
+
+    assert_equal 200, last_response.status, "Unexpected response: #{last_response.body}"
+    assert_includes last_response.body, 'All set up and running!'
+  end
+
+
+  def test_not_found_route
+    get '/random'
+
+    assert_equal 404, last_response.status
+  end
+end

data/lib/rubee/tests/test_helper.rb

@@ -0,0 +1,11 @@
+require_relative File.join(File.expand_path(Dir.pwd), 'lib', 'rubee.rb')
+
+require "bundler/setup"
+Bundler.require(:default, :test, :development)
+
+require 'minitest/autorun'
+require 'rack/test'
+
+Rubee::Autoload.call
+
+

data/lib/rubee/tests/user_model_test.rb

@@ -0,0 +1,51 @@
+require_relative 'test_helper'
+
+describe 'User model' do
+  describe ".create" do
+    after do
+      User.destroy_all
+    end
+
+    describe 'when data is valid' do
+      it 'persists to db' do
+        user = User.create(email: "ok-test@test.com", password: "123")
+
+         _(user.persisted?).must_equal true
+      end
+    end
+
+    describe 'when data is invalid' do
+      it 'is not changing users number' do
+        initial_count = User.all.count
+        User.create(wrong: "test@test") rescue nil
+
+        _(User.all.count).must_equal initial_count
+      end
+    end
+  end
+
+  describe '.save' do
+    after do
+      User.destroy_all
+    end
+
+    describe 'when data is valid' do
+      it 'persists to db' do
+        user = User.new(email: "ok-test@test.com", password: "123")
+        user.save
+
+        _(user.persisted?).must_equal true
+      end
+    end
+
+    describe 'when data is invalid' do
+      it 'is not changing users number' do
+        initial_count = User.all.count
+        user = User.new(wrong: "test@test") rescue nil
+        user.save rescue nil
+
+        _(User.all.count).must_equal initial_count
+      end
+    end
+  end
+end