jun 0.1.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a23824148b7546d35ec51bc05200095f47bb5ffcb3604597a2c1606b893ae1c5
-  data.tar.gz: e6e03e5e69d3cebd025a9194de2488539a096c9864fbb53b720f43c5f7d5f68b
+  metadata.gz: febb60185e9d61a52eb783ec6052f39a35b7a41afca6bf27cf8db4bea718536f
+  data.tar.gz: 8c4068f3c9093bc6b9184d1e9eeda93e06ff4ba11bf826c4dec93feb218efc73
 SHA512:
-  metadata.gz: 0a50ed3137ed9926647d32e534c908a1f6bca9e235a6de53f6969932be97dca05bbb44dec9bffd4d3de3b1b5d96cdcc227b2c0728a176a3433dd98cb85e0b403
-  data.tar.gz: 78931eee706054b9b6f85585b3dd0af3055a9ff6641439802aea254c1f3c0c23292802e4c40147f17bea8e72b6d6e1ce5fe3b85455260ef559ca9dedeadcc40e
+  metadata.gz: '0957dea84721aec8cbb82eeef95d7516c5862960683086686ee6b1ee2e0fae69ff4dbf72d145530d174f9220cd8e384206160a1264a9eba5eeaf334d51bd8674'
+  data.tar.gz: 5e90b858218ba802b04d5d7752f227947493b0c65243437faf8757147c726815794dd6f921521ce438b03ffc66883152379988b4b05058ad70276879c6d26e0d

data/README.md

@@ -1,32 +1,35 @@
 # Jun
 
-Jun is a simple, Rails-inspired web application framework. It is built with the goal of learning more about Rails internals. Not meant for production use.
+[![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
+```
 
-_TBD_
+Visit `http://localhost:6291` to view your app.
 
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` 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 the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+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/jun.gemspec

@@ -9,7 +9,7 @@ Gem::Specification.new do |spec|
   spec.email = ["zspesic@gmail.com"]
 
   spec.summary = "A simple Ruby web framework."
-  spec.description = "A simple web framework inspired by Rails."
+  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"
@@ -24,9 +24,9 @@ Gem::Specification.new do |spec|
   spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_runtime_dependency "rack"
-  spec.add_runtime_dependency "tilt"
-  spec.add_runtime_dependency "sqlite3"
+  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"

data/lib/jun/action_controller/base.rb

@@ -1,20 +1,16 @@
 # frozen_string_literal: true
 
+require_relative "metal"
+require_relative "callbacks"
 require_relative "rendering"
+require_relative "redirecting"
 
 module Jun
   module ActionController
-    class Base
+    class Base < Metal
+      include Jun::ActionController::Callbacks
       include Jun::ActionController::Rendering
-
-      attr_accessor :request, :response
-
-      def handle_response(action)
-        public_send(action)
-        render(action) unless response_rendered?
-
-        response
-      end
+      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

@@ -71,10 +71,6 @@ module Jun
 
       private
 
-      def response_rendered?
-        !!@_response_rendered
-      end
-
       def views_path
         dirname = self.class.name.sub(/Controller\z/, "").underscore
         Jun.root.join("app/views/#{dirname}")

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

@@ -9,10 +9,19 @@ module Jun
         end
 
         def get(path, to:, as: nil)
-          controller, action = to.split("#")
-          path = path.to_s.start_with?("/") ? path.to_s : "/#{path}"
+          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
 
-          @route_set.add_route("GET", path, controller, action, as)
+        def delete(path, to:, as: nil)
+          add_route(:delete, path, to: to, as: as)
         end
 
         def root(to:)
@@ -22,6 +31,22 @@ module Jun
         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

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

@@ -25,7 +25,7 @@ module Jun
 
         def path_regex
           path_string_for_regex = path.gsub(/:\w+/) { |match| "(?<#{match.delete(":")}>\\w+)" }
-          Regexp.new("^#{path_string_for_regex}$")
+          Regexp.new("^#{path_string_for_regex}\/?$")
         end
       end
 
@@ -35,18 +35,21 @@ module Jun
         end
 
         def call(env)
+          return welcome_response if @routes.none?
+
           request = Rack::Request.new(env)
 
           if route = find_route(request)
             route.dispatch(request)
           else
-            [404, { "Content-Type" => "text/plain" }, ["Not found"]]
+            not_found_response
           end
         end
 
         def add_route(*args)
           route = Route.new(*args)
           @routes.push(route)
+          define_url_helper(route)
 
           route
         end
@@ -59,6 +62,50 @@ module Jun
           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

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

@@ -0,0 +1,59 @@
+<!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;
+      }
+
+      .button {
+        background-color: #fc7e70;
+        color: #fff;
+        margin: 0 0.2rem;
+        padding: 0.5rem 0.75rem;
+        border-radius: 3px;
+        text-decoration: none;
+      }
+
+      .docs-links {
+        margin: 1.5rem 0;
+      }
+
+      .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>
+      <p>Get started by checking out the guide or reading up on the docs.</p>
+      <div class="docs-links">
+        <a class="button" href="https://www.rubydoc.info/gems/jun/<%= Jun::VERSION %>#getting-started">Getting Started</a>
+        <a class="button" href="https://www.rubydoc.info/gems/jun/<%= Jun::VERSION %>">Documentation</a>
+      </div>
+      <small>Jun v<%= Jun::VERSION %> | Ruby v<%= RUBY_VERSION %> (<%= RUBY_PLATFORM %>)</small>
+    </div>
+  </body>
+</html>

data/lib/jun/{active_record.rb → active_record/base.rb}

@@ -1,11 +1,15 @@
 # frozen_string_literal: true
 
-require_relative "connection_adapters/sqlite_adapter"
+require_relative "../connection_adapters/sqlite_adapter"
+require_relative "./persistence"
 
 module ActiveRecord
   class Base
+    include ActiveRecord::Persistence
+
     def initialize(attributes = {})
       @attributes = attributes
+      @new_record = true
     end
 
     def method_missing(name, *args)
@@ -21,12 +25,19 @@ module ActiveRecord
     end
 
     def self.all
-      find_by_sql("SELECT * FROM #{table_name}")
+      ActiveRecord::Relation.new(self)
+    end
+
+    def self.where(*args)
+      all.where(*args)
     end
 
     def self.find_by_sql(sql)
       connection.execute(sql).map do |attributes|
-        new(attributes)
+        object = new(attributes)
+        object.instance_variable_set("@new_record", false)
+
+        object
       end
     end
 

data/lib/jun/active_record/migration.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  class Migration
+    def up
+      raise NoMethodError, "Subclass must implement method."
+    end
+
+    def down
+      raise NoMethodError, "Subclass must implement method."
+    end
+
+    def add_column(table_name, column_name, column_type, options = {})
+      sql = ["ALTER TABLE #{table_name} ADD COLUMN #{column_name}"]
+
+      sql << column_type.to_s.upcase
+      sql << "NOT NULL" if options[:null] == false
+      sql << "DEFAULT #{options[:default]}" if options[:default]
+      sql << "UNIQUE" if options[:unique] == true
+
+      execute(sql.join(" "))
+    end
+
+    def remove_column(table_name, column_name)
+      execute("ALTER TABLE #{table_name} DROP COLUMN #{column_name};")
+    end
+
+    def create_table(table_name, options = {})
+      sql = "CREATE TABLE IF NOT EXISTS #{table_name}"
+      column_options = []
+
+      if options[:id] || !options.key?(:id)
+        column_options << {
+          name: :id,
+          type: :integer,
+          primary_key: true,
+          null: false
+        }
+      end
+
+      column_options += options.fetch(:columns, [])
+
+      columns_sql = column_options.map do |column|
+        next(column) if column.is_a?(String)
+
+        column_sql = []
+
+        column_sql << column[:name]
+        column_sql << column[:type]&.to_s&.upcase
+        column_sql << "PRIMARY KEY" if column[:primary_key] == true
+        column_sql << "NOT NULL" if column[:null] == false
+        column_sql << "DEFAULT #{column[:default]}" if column[:default]
+        column_sql << "UNIQUE" if column[:unique] == true
+
+        column_sql.compact.join(" ")
+      end
+
+      sql += " (#{columns_sql.join(", ")})"
+      sql += ";"
+
+      execute(sql)
+    end
+
+    def drop_table(table_name)
+      execute("DROP TABLE IF EXISTS #{table_name};")
+    end
+
+    def rename_table(old_table_name, new_table_name)
+      execute("ALTER TABLE #{old_table_name} RENAME TO #{new_table_name};")
+    end
+
+    def execute(*args)
+      ActiveRecord::Base.connection.execute(*args)
+    end
+  end
+end

data/lib/jun/active_record/migrator.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  class Migrator
+    ALLOWED_DIRECTIONS = %w[up down].freeze
+
+    def initialize(direction:)
+      unless ALLOWED_DIRECTIONS.include?(direction.to_s)
+        raise ArgumentError, "direction must be one of: #{ALLOWED_DIRECTIONS.inspect}"
+      end
+
+      @direction = direction.to_s
+    end
+
+    def call
+      process_migrations!
+    end
+
+    private
+
+    def process_migrations!
+      files_to_process = up_migration? ? pending_migration_files : processed_migration_files.last(1)
+
+      files_to_process.each do |filepath|
+        require filepath
+
+        filename = filepath.split("/").last.sub(".rb", "")
+        migration_version = filename.split("_").first
+        migration_class_name = filename.split("_", 2).last.camelize
+        migration_class = Object.const_get(migration_class_name)
+
+        migration_class.new.public_send(@direction)
+        up_migration? ? add_to_schema_migrations(migration_version) :
+                        remove_from_schema_migrations(migration_version)
+
+        migration_verb = up_migration? ? "processed" : "rolled back"
+        puts "Migration #{migration_verb} (#{filename})."
+      end
+
+      dump_schema! if files_to_process.any?
+    end
+
+    def up_migration?
+      @direction == "up"
+    end
+
+    def pending_migration_files
+      @pending_migration_files ||= migration_files - processed_migration_files
+    end
+
+    def processed_migration_files
+      @processed_migration_files ||= migration_files.select do |filepath|
+        file_version = filepath.split("/").last.split("_").first
+        processed_versions.include?(file_version)
+      end
+    end
+
+    def migration_files
+      @migration_files ||= Dir.glob(Jun.root.join("db/migrate/*.rb")).sort
+    end
+
+    def processed_versions
+      ActiveRecord::Base.connection.execute("SELECT * FROM schema_migrations;").map do |attributes|
+        attributes[:version]
+      end
+    end
+
+    def add_to_schema_migrations(version)
+      ActiveRecord::Base.connection.execute("INSERT INTO schema_migrations (version) VALUES (#{version});")
+    end
+
+    def remove_from_schema_migrations(version)
+      ActiveRecord::Base.connection.execute("DELETE FROM schema_migrations WHERE version = #{version};")
+    end
+
+    def dump_schema!
+      Jun::CLI.process_command(["db:schema:dump"])
+    end
+  end
+end

data/lib/jun/active_record/persistence.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Persistence
+    def self.included(klass)
+      klass.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def create(attributes = {})
+        object = new(attributes)
+        object.save
+
+        object
+      end
+
+      def primary_key=(value)
+        @primary_key = value.to_sym
+      end
+
+      def primary_key
+        defined?(@primary_key) ? @primary_key : :id
+      end
+    end
+
+    def save
+      if new_record?
+        result = self.class.connection.execute(
+          <<~SQL
+            INSERT INTO #{self.class.table_name}
+            (#{@attributes.keys.join(",")})
+            VALUES (#{@attributes.values.map { |v| "'#{v}'" }.join(",")})
+            RETURNING *;
+          SQL
+        )
+
+        @attributes[self.class.primary_key] = result.first[self.class.primary_key]
+        @new_record = false
+      else
+        self.class.connection.execute(
+          <<~SQL
+            UPDATE #{self.class.table_name}
+            SET #{@attributes.map { |k, v| "#{k} = #{v.nil? ? 'NULL' : "'#{v}'"}" }.join(",")}
+            WHERE id = #{id};
+          SQL
+        )
+      end
+
+      true
+    end
+
+    def new_record?
+      @new_record
+    end
+
+    def persisted?
+      !new_record?
+    end
+  end
+end