jun 0.0.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: a0443a05754d92c8facf0a4497603884ed58833f
-  data.tar.gz: ea40d29cd50879cb73bbdd3130ec84684980d097
+SHA256:
+  metadata.gz: 70a404db6997b3aa8f1a682cfaac1d401e5a78aa2c6344645aed5819f9a7c617
+  data.tar.gz: 6ef4729b48e1f780a2004515c00a2ee6efbea77cade3522d942d05f602b509b8
 SHA512:
-  metadata.gz: c282aabb2f3057321548c32de8058e65b13d433f885e71fc5a3ca405351cb609a8a98bc288162f0c8a67591ac2106d63c55d121cd6fdf6c3bc376e0d3f2001c5
-  data.tar.gz: 8fdd848aad1a8cdafd410e0090b4b85a6a09f7b63e0dee7fbd072ed08890e0b2ceebd989a1aca5665458cda3e8a7ac0c2292c78cd0ee6f7ff236888f9ef604ed
+  metadata.gz: fa512bde19df4fb617e5d49f6336433cff2ed31ba3dcfba942ed4473b8136a943ff92afcf0fb0a9dcf3f9ebc795f796393e0340a23bbfec183f7987cab90b841
+  data.tar.gz: 5bf62a8d2e2cfaedfce5435b44bc54388f2792b48459b028436c4baf40c8971a9bb6a53c3e63eda0126087142da5742cee470cb69890c50c2d23af228f883cad

data/.rubocop.yml

@@ -0,0 +1,13 @@
+AllCops:
+  TargetRubyVersion: 2.6
+
+Style/StringLiterals:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Layout/LineLength:
+  Max: 120

data/Gemfile

@@ -1,3 +1,5 @@
-source 'https://rubygems.org'
+# frozen_string_literal: true
+
+source "https://rubygems.org"
 
 gemspec

data/LICENSE.txt

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2016 Zoran Pesic
+Copyright (c) 2021 Zoran Pesic
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -1,37 +1,35 @@
 # Jun
 
-Jun is a simple web application framework inspired by Rails, built with the hopes of learning much more about Rails internals in the process.
+[![Gem Version](https://badge.fury.io/rb/jun.svg)](https://badge.fury.io/rb/jun)
 
-## Installation
+Jun is a simple, [Rails](https://github.com/rails/rails)-inspired web application framework. This is a rough implementation, built with the goal of learning more about Rails internals. Not meant for production use.
 
-Add this line to your application's Gemfile:
+## Getting Started
 
-```ruby
-gem 'jun'
-```
+Install the gem:
 
-And then execute:
+```
+$ gem install jun
+```
 
-    $ bundle
+Then, create a new Jun application:
 
-Or install it yourself as:
+```
+$ jun new my_app
+```
 
-    $ gem install jun
+Change directory into `my_app` and start up the server:
 
-## Usage
+```
+$ cd my_app
+$ bin/jun server
+```
 
-TODO: Write usage instructions here
+Visit `http://localhost:6291` to view your app.
 
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
-
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
-
-## Contributing
-
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/jun.
-
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can run `bin/console` for an interactive prompt that will allow you to experiment.
 
 ## License
 

data/Rakefile

@@ -1,6 +1,16 @@
+# frozen_string_literal: true
+
 require "bundler/gem_tasks"
-require "rspec/core/rake_task"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+require "rubocop/rake_task"
 
-RSpec::Core::RakeTask.new(:spec)
+RuboCop::RakeTask.new
 
-task :default => :spec
+task default: %i[test rubocop]

data/bin/console

@@ -1,14 +1,8 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
 require "bundler/setup"
+require "pry"
 require "jun"
 
-# 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
+Pry.start

data/exe/jun

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "jun"
+require "jun/cli"
+
+Jun::CLI.process_command(ARGV)

data/jun.gemspec

@@ -1,25 +1,35 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'jun/version'
+# frozen_string_literal: true
+
+require_relative "lib/jun/version"
 
 Gem::Specification.new do |spec|
-  spec.name          = "jun"
-  spec.version       = Jun::VERSION
-  spec.authors       = ["Zoran"]
-  spec.email         = ["zoran1991@gmail.com"]
+  spec.name = "jun"
+  spec.version = Jun::VERSION
+  spec.authors = ["Zoran"]
+  spec.email = ["zspesic@gmail.com"]
+
+  spec.summary = "A simple Ruby web framework."
+  spec.description = "A simple web framework inspired by Rails. Not meant for production use."
+  spec.homepage = "https://github.com/zokioki/jun"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 2.6.0"
 
-  spec.summary       = %q{A simple Ruby web framework.}
-  spec.description   = %q{A simple web framework inspired by Rails, built with the hopes of learning more about Rails internals in the process.}
-  spec.homepage      = "https://github.com/zokioki/jun"
-  spec.license       = "MIT"
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (f == __FILE__) || f.match(%r{\A(?:(?:test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
+    end
+  end
 
-  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
-  spec.bindir        = "exe"
-  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
   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", "~> 2.2"
+  spec.add_runtime_dependency "tilt", "~> 2.0"
+  spec.add_runtime_dependency "sqlite3", "~> 1.4"
+
+  spec.add_development_dependency "rake", "~> 13.0"
+  spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_development_dependency "rubocop", "~> 1.21"
+  spec.add_development_dependency "pry", "~> 0.14"
 end

data/lib/jun/action_controller/base.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative "metal"
+require_relative "callbacks"
+require_relative "rendering"
+require_relative "redirecting"
+
+module Jun
+  module ActionController
+    class Base < Metal
+      include Jun::ActionController::Callbacks
+      include Jun::ActionController::Rendering
+      include Jun::ActionController::Redirecting
+    end
+  end
+end

data/lib/jun/action_controller/callbacks.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Jun
+  module ActionController
+    module Callbacks
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      def handle_response(action)
+        self.class.before_actions.each do |callback|
+          callback.call(self) if callback.match?(action)
+        end
+
+        super
+      end
+
+      module ClassMethods
+        def before_action(method_name, options = {})
+          before_actions << Callback.new(method_name, options)
+        end
+
+        def before_actions
+          @before_actions ||= []
+        end
+      end
+
+      class Callback
+        def initialize(method_name, options)
+          @method_name = method_name
+          @options = options
+        end
+
+        def match?(action)
+          return true unless @options[:only]&.any?
+
+          @options[:only].include?(action.to_sym)
+        end
+
+        def call(controller)
+          controller.send(@method_name)
+        end
+      end
+    end
+  end
+end

data/lib/jun/action_controller/metal.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Jun
+  module ActionController
+    class Metal
+      attr_accessor :request, :response
+
+      def handle_response(action)
+        public_send(action)
+        render(action) unless response_rendered?
+
+        response
+      end
+
+      private
+
+      def response_rendered?
+        !!@_response_rendered
+      end
+    end
+  end
+end

data/lib/jun/action_controller/redirecting.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Jun
+  module ActionController
+    module Redirecting
+      def redirect_to(location, options = {})
+        return if response_rendered?
+
+        response.location = location
+        response.status = options[:status] || 302
+        response.write("<html><body>You are being <a href=\"#{response.location}\">redirected</a>.</body></html>")
+
+        @_response_rendered = true
+      end
+    end
+  end
+end

data/lib/jun/action_controller/rendering.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require "tilt/erb"
+require "json"
+
+require_relative "../action_view/base"
+
+module Jun
+  module ActionController
+    module Rendering
+      def render(options, extra_options = {})
+        return if response_rendered?
+
+        template_name = nil
+        if options.is_a?(Symbol) || options.is_a?(String)
+          template_name = options
+          options = extra_options
+        else
+          template_name = options[:template]
+        end
+
+        options[:layout] = true unless options.key?(:layout)
+
+        if content_type = options[:content_type]
+          response.content_type = content_type.to_s
+        end
+
+        if status = options[:status]
+          response.status = status
+        end
+
+        if template_name
+          filepath = views_path.join("#{template_name}.html.erb")
+          template = Tilt::ERBTemplate.new(filepath)
+          context = Jun::ActionView::Base.new(self)
+          body = template.render(context, options[:locals])
+
+          if options[:layout]
+            layout_name = options[:layout].is_a?(String) ? options[:layout] : "application"
+            layout_filepath = layouts_path.join("#{layout_name}.html.erb")
+            layout_template = Tilt::ERBTemplate.new(layout_filepath)
+
+            body = layout_template.render(context) { body }
+          end
+
+          response.write(body)
+          response.content_type ||= "text/html"
+        elsif options[:text]
+          response.write(options[:text])
+          response.content_type ||= "text/plain"
+        elsif options[:json]
+          json = options[:json].is_a?(String) ? options[:json] : JSON.generate(options[:json])
+          response.write(json)
+          response.content_type ||= "application/json"
+        elsif options[:nothing]
+          response.write("")
+          response.content_type ||= "text/plain"
+        end
+
+        @_response_rendered = true
+      end
+
+      def view_assigns
+        reserved_variables = %i[@request @response @_response_rendered]
+        variables = instance_variables - reserved_variables
+
+        variables.reduce({}) do |object, name|
+          object.merge(name[1..-1] => instance_variable_get(name))
+        end
+      end
+
+      private
+
+      def views_path
+        dirname = self.class.name.sub(/Controller\z/, "").underscore
+        Jun.root.join("app/views/#{dirname}")
+      end
+
+      def layouts_path
+        Jun.root.join("app/views/layouts")
+      end
+    end
+  end
+end

data/lib/jun/action_dispatch/routing/mapper.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Jun
+  module ActionDispatch
+    module Routing
+      class Mapper
+        def initialize(route_set)
+          @route_set = route_set
+        end
+
+        def get(path, to:, as: nil)
+          add_route(:get, path, to: to, as: as)
+        end
+
+        def post(path, to:, as: nil)
+          add_route(:post, path, to: to, as: as)
+        end
+
+        def patch(path, to:, as: nil)
+          add_route(:patch, path, to: to, as: as)
+        end
+
+        def delete(path, to:, as: nil)
+          add_route(:delete, path, to: to, as: as)
+        end
+
+        def root(to:)
+          get "/", to: to, as: "root"
+        end
+
+        def resources(plural_name)
+          get "/#{plural_name}", to: "#{plural_name}#index", as: plural_name.to_s
+          get "/#{plural_name}/new", to: "#{plural_name}#new", as: "new_#{plural_name.to_s.singularize}"
+          post "/#{plural_name}", to: "#{plural_name}#create"
+          get "/#{plural_name}/:id", to: "#{plural_name}#show", as: plural_name.to_s.singularize
+          get "/#{plural_name}/:id/edit", to: "#{plural_name}#edit", as: "edit_#{plural_name.to_s.singularize}"
+          patch "/#{plural_name}/:id", to: "#{plural_name}#update"
+          delete "/#{plural_name}/:id", to: "#{plural_name}#destroy"
+        end
+
+        private
+
+        def add_route(method, path, to:, as: nil)
+          method = method.to_s.upcase
+          controller, action = to.split("#")
+          path = path.to_s.start_with?("/") ? path.to_s : "/#{path}"
+          as ||= path.sub("/", "")
+
+          @route_set.add_route(method, path, controller, action, as)
+        end
+      end
+    end
+  end
+end

data/lib/jun/action_dispatch/routing/route_set.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require_relative "mapper"
+
+module Jun
+  module ActionDispatch
+    module Routing
+      class Route < Struct.new(:method, :path, :controller, :action, :name)
+        def match?(request)
+          request.request_method == method && path_regex.match?(request.path_info)
+        end
+
+        def dispatch(request)
+          controller = controller_class.new
+          controller.request = request
+          controller.response = Rack::Response.new
+          controller.handle_response(action)
+          controller.response.finish
+        end
+
+        def controller_class
+          class_name = "#{controller.camelize}Controller"
+          Object.const_get(class_name)
+        end
+
+        def path_regex
+          path_string_for_regex = path.gsub(/:\w+/) { |match| "(?<#{match.delete(":")}>\\w+)" }
+          Regexp.new("^#{path_string_for_regex}\/?$")
+        end
+      end
+
+      class RouteSet
+        def initialize
+          @routes = []
+        end
+
+        def call(env)
+          return welcome_response if @routes.none?
+
+          request = Rack::Request.new(env)
+
+          if route = find_route(request)
+            route.dispatch(request)
+          else
+            not_found_response
+          end
+        end
+
+        def add_route(*args)
+          route = Route.new(*args)
+          @routes.push(route)
+          define_url_helper(route)
+
+          route
+        end
+
+        def find_route(request)
+          @routes.detect { |route| route.match?(request) }
+        end
+
+        def draw(&block)
+          mapper = Jun::ActionDispatch::Routing::Mapper.new(self)
+          mapper.instance_eval(&block)
+        end
+
+        def url_helpers
+          @url_helpers ||= Module.new.extend(url_helpers_module).include(url_helpers_module)
+        end
+
+        private
+
+        def url_helpers_module
+          @url_helpers_module ||= Module.new
+        end
+
+        def define_url_helper(route)
+          path_name = "#{route.name}_path"
+
+          url_helpers_module.define_method(path_name) do |*args|
+            options = args.last.is_a?(Hash) ? args.pop : {}
+            path = route.path
+            path_tokens = path.scan(/:\w+/)
+
+            path_tokens.each.with_index do |token, index|
+              path.sub!(token, args[index])
+            end
+
+            path
+          end
+        end
+
+        def not_found_response
+          response = Rack::Response.new
+          response.content_type = "text/plain"
+          response.status = 404
+          response.write("Not found")
+          response.finish
+        end
+
+        def welcome_response
+          template_filepath = File.expand_path("welcome.html.erb", __dir__)
+          template = Tilt::ERBTemplate.new(template_filepath)
+
+          response = Rack::Response.new
+          response.content_type = "text/html"
+          response.write(template.render)
+          response.finish
+        end
+      end
+    end
+  end
+end

data/lib/jun/action_dispatch/routing/welcome.html.erb

@@ -0,0 +1,41 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <title>Welcome to Jun!</title>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+
+    <style>
+      body {
+        font-family: -apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,Oxygen-Sans,Ubuntu,Cantarell,"Helvetica Neue",sans-serif;
+        background-color: #fff3f3;
+        color: #7d3737;
+      }
+
+      ::selection {
+        background-color: #ffbdb6;
+      }
+
+      .root {
+        margin-top: 4rem;
+        text-align: center;
+      }
+
+      .sunspot {
+        width: 100px;
+        height: 100px;
+        border-radius: 50%;
+        background-color: #fc7e70;
+        margin: 2rem auto;
+      }
+    </style>
+  </head>
+
+  <body>
+    <div class="root">
+      <div class="sunspot"></div>
+      <h1>Welcome to Jun!</h1>
+      <small>Jun v<%= Jun::VERSION %> | Ruby v<%= RUBY_VERSION %> (<%= RUBY_PLATFORM %>)</small>
+    </div>
+  </body>
+</html>

data/lib/jun/action_view/base.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative "helpers"
+
+module Jun
+  module ActionView
+    class Base
+      include Jun::ActionView::Helpers
+
+      attr_reader :controller
+
+      def initialize(controller)
+        @controller = controller
+        assign_instance_variables
+      end
+
+      private
+
+      def assign_instance_variables
+        controller.view_assigns.each do |name, value|
+          instance_variable_set("@#{name}", value)
+        end
+      end
+    end
+  end
+end

data/lib/jun/action_view/helpers/url_helper.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Jun
+  module ActionView
+    module Helpers
+      module UrlHelper
+        def link_to(title, url, options = {})
+          %Q{<a href="#{url}"#{ "class=\"#{options[:class]}\"" if options[:class] }>#{title}</a>}
+        end
+      end
+    end
+  end
+end

data/lib/jun/action_view/helpers.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative "helpers/url_helper"
+
+module Jun
+  module ActionView
+    module Helpers
+      include Jun::ActionView::Helpers::UrlHelper
+    end
+  end
+end