Nobody/main page

public/.gitignore

@@ -1,3 +1,2 @@
 **/*
-!css
 !.gitignore

src/crystaldoc.cr

@@ -5,3 +5,4 @@ end
 require "./crystaldoc/db"
 require "./crystaldoc/worker"
 require "./crystaldoc/server"
+require "./crystaldoc/views"

src/crystaldoc/db.cr

@@ -3,14 +3,6 @@ require "pg"
 require "json"
 
 module CrystalDoc
-  SERVICE_HOSTS = {
-    "github.com" => "github",
-    "gitlab.com" => "gitlab",
-    "git.sr.ht" => "git-sr-ht",
-    "hg.sr.ht" => "hg-sr-ht",
-    "codeberg.org" => "codeberg",
-  }
-
   alias RepoId = Int32
   alias VersionId = Int32
 
@@ -35,7 +27,7 @@ module CrystalDoc
       db.scalar(
         "INSERT INTO crystal_doc.repo_version (repo_id, commit_id, nightly)
          VALUES ($1, $2, $3)
-         RETURNING id", 
+         RETURNING id",
         repo_id, commit_id, nightly).as(Int32)
     end
 
@@ -44,7 +36,7 @@ module CrystalDoc
         "INSERT INTO crystal_doc.doc_job (version_id, priority)
          VALUES ($1, $2)
          RETURNING id",
-         version_id, priority).as(Int32)
+        version_id, priority).as(Int32)
     end
 
     def self.upsert_repo_status(db : Queriable, repo_id : RepoId)
@@ -89,7 +81,7 @@ module CrystalDoc
 
     def self.get_versions(db : Queriable, repo_id : RepoId) : Array(Repo)?
       CrystalDoc::RepoVersion.from_rs(
-          db.query(
+        db.query(
           "SELECT repo_version.id, repo_version.repo_id, repo_version.commit_id, repo_version.nightly
            FROM crystal_doc.repo_version
            WHERE repo_id = $1", id))
@@ -112,27 +104,31 @@ module CrystalDoc
       "/#{service}/#{username}/#{project_name}"
     end
 
-    def self.from_kemal_env(env) : Array(Repo) | Nil
+    def self.uri_to_service(uri : URI) : String
+      if (host = uri.host).nil?
+        raise "No host: #{uri}"
+      end
+
+      host.gsub(/\.com$/, "").gsub(/\./, "-")
+    end
+
+    def self.from_kemal_env(env) : Repo?
       DB.open(ENV["POSTGRES_DB"]) do |db|
-        service = env.params.url["serv"]
-        username = env.params.url["user"]
-        project_name = env.params.url["proj"]
-        CrystalDoc::Repo.from_rs(
-          db.query(
-            "SELECT * FROM crystal_doc.repo WHERE service = $1 AND username = $2 AND project_name = $3",
-            service, username, project_name
-          )
+        db.query_one(
+          "SELECT * FROM crystal_doc.repo WHERE service = $1 AND username = $2 AND project_name = $3",
+          env.params.url["serv"], env.params.url["user"], env.params.url["proj"],
+          as: Repo
         )
       end
     end
 
     def self.create(source_url : String)
       uri = URI.parse(source_url).normalize
-      service = SERVICE_HOSTS[uri.host] || raise "No known service: #{uri.host}"
-
+
       path_fragments = uri.path.split('/')[1..]
       raise "Invalid url component: #{uri.path}" if path_fragments.size != 2
 
+      service = self.uri_to_service(uri)
       username = path_fragments[0]
       project_name = path_fragments[1]
 
@@ -155,20 +151,20 @@ module CrystalDoc
 
     def versions_to_json
       {
-        "versions" => versions.map do |version|
+        "versions" => versions.reverse.map do |version|
           {
-            "name" => "#{version.commit_id}",
-            "url" => "#{path}/index.html",
-            "released" => !version.nightly
+            "name"     => "#{version.commit_id}",
+            "url"      => "#{path}/#{version.commit_id}/",
+            "released" => !version.nightly,
           }
-        end
+        end,
       }.to_json
     end
 
     def status : RepoStatus
       DB.open(ENV["POSTGRES_DB"]) do |db|
         CrystalDoc::RepoStatus.from_rs(
-          db.query "SELECT * FROM crystal_doc.repo_status WHERE repo_id = $1", id 
+          db.query "SELECT * FROM crystal_doc.repo_status WHERE repo_id = $1", id
         )
       end
     end
@@ -189,20 +185,20 @@ module CrystalDoc
         "SELECT repo_version.id, repo_version.repo_id, repo_version.commit_id, repo_version.nightly
          FROM crystal_doc.repo_version
          WHERE repo.service = $1 AND repo.username = $2 AND repo.project_name = $3",
-        service, username, project_name,) { |rs| CrystalDoc::RepoVersion.from_rs(rs) }
+        service, username, project_name) { |rs| CrystalDoc::RepoVersion.from_rs(rs) }
     end
 
     def self.parse_url(repo_url : String) : {service: String, username: String, project_name: String}
       uri = URI.parse(repo_url).normalize
-      service = CrystalDoc::SERVICE_HOSTS[uri.host] || raise "No known service: #{uri.host}"
-      
+      service = uri_to_service(uri)
+
       path_fragments = uri.path.split('/')[1..]
       raise "Invalid url component: #{uri.path}" if path_fragments.size != 2
 
       username = path_fragments[0]
       project_name = path_fragments[1]
 
-      { service: service, username: username, project_name: project_name }
+      {service: service, username: username, project_name: project_name}
     end
 
     def self.build_path(service : String, username : String, project_name : String)
@@ -215,11 +211,11 @@ module CrystalDoc
       {
         "versions" => versions.map do |version|
           {
-            "name" => "#{version.commit_id}",
-            "url" => "#{path}/index.html",
-            "released" => !version.nightly
+            "name"     => "#{version.commit_id}",
+            "url"      => "#{path}/index.html",
+            "released" => !version.nightly,
           }
-        end
+        end,
       }.to_json
     end
   end
@@ -236,11 +232,18 @@ module CrystalDoc
     end
 
     def self.create(repo : Repo, commid_id : String, nightly : Bool)
-
     end
 
     def self.create(repo_id, version)
+    end
 
+    def self.find(repo_id : Int32, str : String) : RepoVersion
+      DB.open(ENV["POSTGRES_DB"]) do |db|
+        db.query_one(
+          "SELECT * FROM crystal_doc.repo_version WHERE repo_id = $1 AND commit_id = $2",
+          repo_id, str, as: RepoVersion
+        )
+      end
     end
   end
 

src/crystaldoc/html.cr

@@ -20,4 +20,4 @@ module CrystalDoc
       end
     end
   end
-end
+end

src/crystaldoc/server.cr

@@ -4,46 +4,54 @@ require "pg"
 require "semantic_version"
 require "ecr"
 
+# Need to create the doc.js
+Dir.mkdir_p("public/css", 0o744)
+Dir.mkdir_p("public/js", 0o744)
+File.write "public/css/style.css", CrystalDoc::Views::StyleTemplate.new
+File.write "public/js/doc.js", CrystalDoc::Views::JsTypeTemplate.new
+
 get "/" do
   render "src/views/main.ecr", "src/views/layouts/layout.ecr"
 end
 
 get "/:serv/:user/:proj" do |env|
   repo = CrystalDoc::Repo.from_kemal_env(env)
-  unless repo.nil?
-    repo = repo.first
-
-    unless repo.versions.size > 0 && File.exists?("public/#{repo.path}/#{repo.versions.first}")
-      puts CrystalDoc::Worker.generate_docs(repo)
-    end
-
-    env.redirect "/#{repo.path}/latest"
-  end
+  env.redirect "#{repo.path}/latest"
 end
 
 get "/:serv/:user/:proj/latest" do |env|
-  repo = CrystalDoc::Repo.from_kemal_env(env)
-  unless repo.nil?
-    repo = repo.first
-    env.redirect "/#{repo.path}/index.html"
+  DB.open(ENV["POSTGRES_DB"]) do |db|
+    db.transaction do |tx|
+      latest_version = CrystalDoc::Queries.get_latest_version(db,
+        env.params.url["serv"], env.params.url["user"], env.params.url["proj"]
+      )
+
+      unless latest_version.nil?
+        env.redirect "./#{latest_version.commit_id}/"
+      end
+    end
   end
 end
 
 get "/:serv/:user/:proj/versions.json" do |env|
   repo = CrystalDoc::Repo.from_kemal_env(env)
   unless repo.nil?
-    repo = repo.first
-
     repo.versions_to_json
   end
 end
 
-get "/:serv/:user/:proj/new_version" do |env|
-  new_version = env.params.query["new_version"]
+get "/:serv/:user/:proj/:version/" do |env|
+  repo = CrystalDoc::Repo.from_kemal_env(env)
+  version = CrystalDoc::RepoVersion.find(repo.id, env.params.url["version"])
+  unless repo.nil? || version.nil? || File.exists?("public#{repo.path}/#{env.params.url["version"]}")
+    CrystalDoc::Worker.generate_docs(repo, version)
+  end
+
+  env.redirect("#{repo.path}/#{version.commit_id}/index.html")
 end
 
-get "/new_repository" do |env|
-  url = env.params.query["repo_url"]
+post "/new_repository" do |env|
+  url = env.params.body["url"].as(String)
 
   # TODO: Need to handle URL redirects, is detectable with git ls-remote, just need to parse proper url out of output.  Not sure how to best structure the code.
   if !valid_vcs_url?(url)
@@ -54,13 +62,13 @@ get "/new_repository" do |env|
     add_new_repo(url)
     "Repo added to database"
   end
-rescue ex
-  "Repository failed to be created: #{ex}"
+  # rescue ex
+  #   "Repository failed to be created: #{ex}"
 end
 
 get "/pending_jobs" do |env|
   limit = env.params.query["limit"]?.try &.to_i32
-  
+
   html = ""
   DB.open(ENV["POSTGRES_DB"]) do |db|
     jobs = CrystalDoc::DocJob.select(db, limit)
@@ -81,7 +89,7 @@ def git_ls_remote(repo_url : String, output : Process::Stdio = Process::Redirect
 end
 
 def get_git_versions(repo_url : String, &)
-  stdout = IO::Memory.new()
+  stdout = IO::Memory.new
   unless git_ls_remote(repo_url, stdout)
     raise "git ls-remote failed"
   end
@@ -97,8 +105,8 @@ def get_git_versions(repo_url : String, &)
   end
 end
 
-LATEST_PRIORITY = 1000
-HISTORICAL_PRIORITY = -10
+LATEST_PRIORITY     = 1000
+HISTORICAL_PRIORITY =  -10
 
 def add_new_repo(repo_url : String)
   repo_info = CrystalDoc::Repo.parse_url(repo_url)
@@ -116,10 +124,9 @@ def add_new_repo(repo_url : String)
 
         # Don't record version until we've tried to parse the version
         version_id = CrystalDoc::Queries.insert_version(conn, repo_id, tag)
-        versions.push({ id: version_id, normalized_form: normalized_version })
-
+        versions.push({id: version_id, normalized_form: normalized_version})
       rescue ArgumentError
-        puts "Unknown version format \"#{ tag }\" from repo \"#{ repo_url }\""
+        puts "Unknown version format \"#{tag}\" from repo \"#{repo_url}\""
       end
 
       versions = versions.sort_by { |version| version[:normalized_form] }