Deploying to gh-pages from @ scala-text/scala_text@50425af 🚀

Author: xuwei-k

lockfileVersion/IDE.html

@@ -0,0 +1,8 @@
+scalaVersion := "2.13.15"
+
+crossScalaVersions += "3.6.2"
+
+libraryDependencies ++= Seq(
+  "org.scalikejdbc" %% "scalikejdbc" % "4.3.2",
+  "org.mindrot"     %  "jbcrypt"     % "0.4"
+)

lockfileVersion/advanced-trait-di.html

@@ -0,0 +1 @@
+sbt.version=1.10.7

lockfileVersion/basic.html

@@ -0,0 +1,8 @@
+package domain
+
+case class User(id: Long, name: String, hashedPassword: String)
+
+object User {
+  def apply(name: String, hashedPassword: String): User =
+    User(0L, name, hashedPassword)
+}

lockfileVersion/case-class-and-pattern-matching.html

@@ -0,0 +1,58 @@
+package domain
+
+import org.mindrot.jbcrypt.BCrypt
+import scalikejdbc._
+
+class UserService {
+  val maxNameLength = 32
+
+  // ストレージ機能
+  def insert(user: User): User = DB localTx { implicit s =>
+    val id = sql"""insert into users (name, password) values (${user.name}, ${user.hashedPassword})"""
+      .updateAndReturnGeneratedKey.apply()
+    user.copy(id = id)
+  }
+
+  def createUser(rs: WrappedResultSet): User =
+    User(rs.long("id"), rs.string("name"), rs.string("password"))
+
+  def find(name: String): Option[User] = DB readOnly { implicit s =>
+    sql"""select * from users where name = $name """
+      .map(createUser).single.apply()
+  }
+
+  def find(id: Long): Option[User] = DB readOnly { implicit s =>
+    sql"""select * from users where id = $id """
+      .map(createUser).single.apply()
+  }
+
+  // パスワード機能
+  def hashPassword(rawPassword: String): String =
+    BCrypt.hashpw(rawPassword, BCrypt.gensalt())
+
+  def checkPassword(rawPassword: String, hashedPassword: String): Boolean =
+    BCrypt.checkpw(rawPassword, hashedPassword)
+
+  // ユーザー登録
+  def register(name: String, rawPassword: String): User = {
+    if (name.length > maxNameLength) {
+      throw new Exception("Too long name!")
+    }
+    if (find(name).isDefined) {
+      throw new Exception("Already registered!")
+    }
+    insert(User(name, hashPassword(rawPassword)))
+  }
+
+  // ユーザー認証
+  def login(name: String, rawPassword: String): User = {
+    find(name) match {
+      case None       => throw new Exception("User not found!")
+      case Some(user) =>
+        if (!checkPassword(rawPassword, user.hashedPassword)) {
+          throw new Exception("Invalid password!")
+        }
+        user
+    }
+  }
+}

lockfileVersion/class.html

@@ -0,0 +1,9 @@
+scalaVersion := "2.13.15"
+
+crossScalaVersions += "3.6.2"
+
+libraryDependencies ++= Seq(
+  "org.scalikejdbc" %% "scalikejdbc" % "4.3.2",
+  "org.mindrot" % "jbcrypt" % "0.4",
+  "org.scalatest" %% "scalatest-wordspec" % "3.2.19" % "test"
+)

lockfileVersion/collection.html

@@ -0,0 +1 @@
+sbt.version=1.10.7

lockfileVersion/control-syntax.html

@@ -0,0 +1,17 @@
+package domain
+
+import org.mindrot.jbcrypt.BCrypt
+
+trait PasswordService {
+  def hashPassword(rawPassword: String): String
+
+  def checkPassword(rawPassword: String, hashedPassword: String): Boolean
+}
+
+trait PasswordServiceImpl extends PasswordService {
+  def hashPassword(rawPassword: String): String =
+    BCrypt.hashpw(rawPassword, BCrypt.gensalt())
+
+  def checkPassword(rawPassword: String, hashedPassword: String): Boolean =
+    BCrypt.checkpw(rawPassword, hashedPassword)
+}

lockfileVersion/error-handling.html

@@ -0,0 +1,8 @@
+package domain
+
+case class User(id: Long, name: String, hashedPassword: String)
+
+object User {
+  def apply(name: String, hashedPassword: String): User =
+    User(0L, name, hashedPassword)
+}

lockfileVersion/example_projects/trait-example/build.sbt

@@ -0,0 +1,33 @@
+package domain
+
+import scalikejdbc._
+
+trait UserRepository {
+  def insert(user: User): User
+
+  def find(name: String): Option[User]
+
+  def find(id: Long): Option[User]
+}
+
+trait UserRepositoryImpl extends UserRepository {
+  def insert(user: User): User = DB localTx { implicit s =>
+    val id = sql"""insert into users (name, password) values (${user.name}, ${user.hashedPassword})"""
+      .updateAndReturnGeneratedKey.apply()
+    user.copy(id = id)
+  }
+
+  def createUser(rs: WrappedResultSet): User =
+    User(rs.long("id"), rs.string("name"), rs.string("password"))
+
+  def find(name: String): Option[User] = DB readOnly { implicit s =>
+    sql"""select * from users where name = $name """
+      .map(createUser).single.apply()
+  }
+
+  def find(id: Long): Option[User] = DB readOnly { implicit s =>
+    sql"""select * from users where id = $id """
+      .map(createUser).single.apply()
+  }
+}
+

lockfileVersion/example_projects/trait-example/project/build.properties

@@ -0,0 +1,30 @@
+package domain
+
+trait UserService {
+  self: PasswordService with UserRepository =>
+
+  val maxNameLength = 32
+
+  def register(name: String, rawPassword: String): User = {
+    if (name.length > maxNameLength) {
+      throw new Exception("Too long name!")
+    }
+    if (find(name).isDefined) {
+      throw new Exception("Already registered!")
+    }
+    insert(User(name, hashPassword(rawPassword)))
+  }
+
+  def login(name: String, rawPassword: String): User = {
+    find(name) match {
+      case None       => throw new Exception("User not found!")
+      case Some(user) =>
+        if (!checkPassword(rawPassword, user.hashedPassword)) {
+          throw new Exception("Invalid password!")
+        }
+        user
+    }
+  }
+}
+
+class UserServiceImpl extends UserService with PasswordServiceImpl with UserRepositoryImpl

lockfileVersion/example_projects/trait-example/src/main/scala/domain/User.scala

@@ -0,0 +1,30 @@
+package domain
+
+import org.scalatest._
+import org.scalatest.wordspec.AnyWordSpec
+
+class UserServiceSpec extends AnyWordSpec {
+  val user = User(1, "test_name", "test_password")
+
+  val sut = new UserService with PasswordServiceImpl with UserRepository {
+    def find(id: Long): Option[domain.User] = Some(user)
+    def find(name: String): Option[domain.User] = Some(user)
+    def insert(user: domain.User): domain.User = user
+  }
+
+  "register" should {
+    "throw an exception if a name is too long" in {
+      val exception = intercept[Exception] {
+        sut.register("too long name" * 100, "password")
+      }
+      assert(exception.getMessage === "Too long name!")
+    }
+
+    "throw an exception if a name is already registered" in {
+      val exception = intercept[Exception] {
+        sut.register("test_name", "password")
+      }
+      assert(exception.getMessage === "Already registered!")
+    }
+  }
+}