A sample showing iteration between scala actors and android.Activity

Extending activity with a trait  to receive events from another actors, services, or any other source ( listeners , as a observer … )

class MainActivity extends Activity
                      with ActivityUtil
                      with Reactive { 

    override def onCreate(savedInstanceState: Bundle) {
        super.onCreate(savedInstanceState) 

        setContentView(R.layout.main) 

        button(R.id.Button01).onClicked {
            app.actor ! Ping(this)
        }
    } 

    onReact {
        case Pong(count) => onUi {
            textView(R.id.Label1).setText("Pong -> " + count)
        }
    }
} 

Isn’t she pretty ?

1. ActivityUtil
   • Allow us to access activity components directly

     
     button(R.id.Button01)

2. Reactive
   • Converts the activity into a scala actor
   • Calling onReact with the desired partialFunctions, allow us to manage the external events

     
     onReact {
         case Pong(count) => onUi {
             textView(R.id.Label1).setText("Pong -> " + count)
         }
     } 

     One problem, onReact resides inside another thread ( the actor one ), so to access components of the view, we must use onUi function

3. ViewConversions
   • With a bunch of implicit conversions, we can implement Listeners directly with functions

     
     button(R.id.Button01).onClicked {
         app.actor ! Ping(this)
     } 

4. The application class contains the other actor who returns Pong

   
   
   class App extends Application {
       val actor = new SampleActor 
   
       override def onCreate(): Unit = {
           actor.start
       }
   } 
   
   case class Pong(count: Int)
   case class Ping(a: Actor) 
   
   class SampleActor extends Actor with L {
       private var count = 0
       def act() {
           loop {
               receive {
                   case Ping(a) => {
                       count = count + 1
                       a ! Pong(count)
                   }
               }
           }
       }
   }
   

I just remembered why I love scala so much

PD: I used giter8 to get a scala-android template

 g8 gseitz/android-sbt-project 

• giter8  https://github.com/n8han/giter8
• template home https://github.com/gseitz/android-sbt-project.g8
• scala-home http://www.scala-lang.org/
• sample-code https://github.com/jgoday/sample_android_scala_actor

Get it from :

• github source
• sample snapshot

To change where to search wallpapers edit src/extension.js and set

const DIRECTORIES = [
       "/usr/share/backgrounds",
       GLib.get_home_dir() + "/Pictures",
       "another_directory"
];

with the image directories that you want.

By default it searchs in /usr/share/backgrounds AND $HOME/Pictures

a kate plugin to open and visualize open files.

• Open a new file (win + O)
  
  
• View open files (win + B)
  
  

• Here’s a small sample of a openoffice 3 extension using scala and sbt
• Project link: sample scala addon
• Openoffice devel documentation: DevGuide and sdk samples :
  folder examples/ on openoffice sdk (usually located in /usr/lib/openoffice-dev)
• I just ported ProtocolHandlerAddon_java to scala and sbt
  under examples/DevelopersGuide/Components/Addons/ProtocolHandlerAddon_java
• using sbt,
  a little task (create_extension) will help to create the oxt file (with the .xcu files, scala-library jar, manifest …)

  $> sbt
     :> update
     :> compile
     :> package
     :> create_extension
  

The sample has two main classes

• 1: JQueryDialog

  Allow create generic dialogs from templates or with explicit content
  We can create a dialog like this :

  
  new JQueryDialog(<div>Dialog content</div>) {
      override def elementId = "dialog_id"
      override def options = "modal:true" ::
                             "title:'dialog title!'" ::
                             "open: function (event, ui) {alert('dialog is opening!');}" ::
                              super.options
  }
  
  

• 2: FormDialog
  To create generic dialogs from templates and with default actions (close)

  
  val item = new Item
  def _template: NodeSeq = bind("item",
              TemplateFinder.findAnyTemplate("templates-hidden/item" :: Nil) openOr
                                             <div>{"Cannot find template"}</div>,
              "name" -> item.name.toForm)
  
  val dialog = new FormDialog(true) {
      override def getFormContent = _template
      override def confirmDialog: NodeSeq = SHtml.ajaxSubmit("save",
              () => {println(item);this.closeCmd}) ++ super.confirmDialog
  }
  
  

type ObjectWithName = {
    def getName: String
}

trait NicePerson[T <: ObjectWithName] {
    def greet: String = {
        "Hello ! My name is %s".format(this.asInstanceOf[ObjectWithName].getName)
    }
}

class Person(name: String) {
    def getName: String = name
}

val peter = new Person("Peter") with NicePerson[Person]
println(peter.greet) // = Hello ! My name is Peter

How nice it is ?

Some references:
http://markthomas.info/blog/?p=92
http://codemonkeyism.com/scala-goodness-structural-typing/

The result would be something like that:

var find = FIND(Item)
    WITH(ItemType.name AS type_name, ItemResponsible.name as responsible)
    WHEN (
        "type_name" ILIKE _nameVariable,
        "cancelled" IS_NULL,
        OR (
            "responsible" IS_NULL,
            "ItemResponsible.id" EQUALS _getLoggedUserID()
        )
    )
    LIMIT 100 OFFSET 20

...
performSearch(find)

Here’s a sample code

// types
type Condition = (() => Boolean, () => String)
type Operator  = (String, List[Condition])    

def _mergeConditions(operator: Operator): String = {
    var shouldApplyAndOperator = false // ????      

    var sql = ""
    var operatorFilters = ""
    val (operatorSQL, conditions) = operator

    var shouldApplyOperatorFilters = false

    conditions.foreach(cdt => {
        val (condition, filter) = cdt

        if (condition()) {
            val filterValue = shouldApplyOperatorFilters match {
                case true  => " %s (%s) ".format(operatorSQL, filter())
                case _ => " %s ".format(filter())
            }                                                          

            operatorFilters += filterValue
            shouldApplyOperatorFilters = true
        }
    })                                       

    if (shouldApplyOperatorFilters) {
        val filterValue = shouldApplyAndOperator match {
            case true  => " %s (%s) ".format("AND", operatorFilters)         

            case _ => " %s ".format(operatorFilters)                         

        }                                                                       

        sql += filterValue
        shouldApplyAndOperator = true
    }                                                                           

    sql
}                                                                               

// Base class to search objects
class Find(obj: String) {
    private var fields: List[Any]         = List()
    private var operators: List[Operator] = List()

    def toSQL: String = {
        def _getFieldsAsSQL = this.fields.reduceLeft(_ + "," + _)
        def _getTableName = this.obj
        def _getOperatorsAsSQL = {
            var sql = ""                                         

            this.operators.foreach(op => {
                sql += _mergeConditions(op)
            })                             

            if (sql != "") sql = " WHERE " + sql
            sql
        }                                       

        "SELECT %s FROM %s %s".format(
                _getFieldsAsSQL,
                _getTableName,
                _getOperatorsAsSQL)
    }                                 

    /**
     * Adds a list of conditions around a sql AND operator
     */
    def AND(conditions: Condition*): Find = {
        this.operators = ("AND", conditions.toList) :: this.operators
        this
    }                                                                

    /**
     * Adds a list of conditions around a sql OR operator
     */
    def OR(conditions: Condition*): Find = {
        this.operators = ("OR",  conditions.toList) :: this.operators
        this
    }                                                                

    /**
     * Selects the object with custom fields
     */
    def WITH(fields: Any*): Find = {
        this.fields = fields.toList ::: this.fields
        this
    }
}                                                  

/** Global operator methods to composite conditions around a find object **/
def AND(conditions: Condition*): Condition = {
    (() => true, () => _mergeConditions("AND", conditions.toList))        

}                                                                           

def OR(conditions: Condition*): Condition = {
    (() => true, () => _mergeConditions("OR", conditions.toList))
}                                                                

// CONDITIONS AND WRAPPERS

class StaticConditionWrapper(filter: String) extends FunctionConditionWrapper(()
=> filter)
class FunctionConditionWrapper(filter: () => String) {                       

    def ALWAYS: Condition = {
        (() => true, filter)
    }
    def IF(condition: () => Boolean): Condition = {
        (condition, filter)
    }
    def IF(value: Boolean): Condition = {
        (() => value, filter)
    }
    def ILIKE(value: String): Condition = {
        (() => value != "", () => " %s ILIKE '%%%s%%' ".format(filter(),
value))
    }
    def IS_NULL: Condition = {
        (() => true, () => " %s IS NULL ".format(filter()))
    }
    def NOT_NULL: Condition = {
        (() => true, () => " %s IS NOT NULL ".format(filter()))
    }
}

implicit def IF(filter: String) = new StaticConditionWrapper(filter)
implicit def IF(filter: () => String) = new FunctionConditionWrapper(filter)

// Object FIND to easy create find objects (FIND("object_name"))
object FIND {
    def apply(obj: String): Find = new Find(obj)
}

The result of evaluting

// TEST
def checkCondition: () =>> Boolean = () => true
def someFilter: () => String = () => " something true"

val f = (
    FIND("ObjectName") WITH(1,2,3,4,5)
    AND (
        someFilter ALWAYS,
        "A" IF true,
        "B" IF checkCondition,
        OR (
            "C" ALWAYS,
            AND (
                "NAME" ILIKE "Pepe",
                "CANCELLED" IS_NULL
            )
        )
    )
)

println(f.toSQL)

is

SELECT 1,2,3,4,5 FROM ObjectName
    WHERE
    something true AND (A)  AND (B)  AND
        (  C  OR (   NAME ILIKE '%Pepe%'   AND ( CANCELLED IS NULL )  )  )

really nice

All filtering is based on

• Conditions :

  
  type Condition = (() => Boolean, () => String)
  
  sample : (() => {result_of_checking_condition()),
            () => {create_some_sql_filter()})
  

  A couple, containing a function that will decide if the filter applies or not,
  and a function that makes the filter

• Operators :

  
  type Operator = (String, List[Condition])
  

  Allows to composite conditions and envolves them with a SQL Operator (And/Or)

• First we define a changeLogger trait that extends Mapper

  
  trait ChangeLogger[T <: Mapper[T] ] {
      def checkChanges(obj: T): Unit = {
          if (obj.dirty_?) {
  
              Log.debug("Object " + obj.getSingleton.dbTableName + " has changed")
  
              obj.formFields.foreach(f => {
                  f.dirty_? match {
                      case true => Log.debug(" ---> Property %s was='%s' and now is = '%s'".format(f.name, f.is.toString, f.was.toString))
                  }
              })
          }
      }
  }
  
  

• Extend LongKeyedMetaMapper (or any other MetaMapper class) to call ChangeLogger checkChanges method after save (or after delete …)

  
  trait ChangeLoggerMetaMapper[T <: LongKeyedMapper[T]] extends LongKeyedMetaMapper[T]
                                                  with ChangeLogger[T] { self : T =>
      override def afterSave: List[(T) => Unit] = checkChanges _ :: super.afterSave
  }
  
  
  

• Model object

  
  class Item extends LongKeyedMapper[Item] with IdPK
                                           with ChangeLogger[Item] {
      def getSingleton = Item
  
      object name extends MappedString(this, 100) {
          override def validations = valMinLen(1, "Must be not empty") _ ::
                                     valUnique("Name must be unique") _ ::
                                     super.validations
      }
  }
  
  object Item extends Item with ChangeLoggerMetaMapper[Item] {
      def findByName(name: String): List[Item] = {
          Item.findAll(By(Item.name, name))
      }
  }
  
  
  

The code can be found on http://github.com/jgoday/sample_lift_testing

Documentation for lift-mapper (version lift-1.1-M6) http://scala-tools.org/mvnsites/liftweb-1.1-M6/lift-mapper/scaladocs/index.html

• 1- Create the menu in boot

  in src/main/scala/bootstrap/liftweb/Boot.scala

  
  // List items menu
  val itemsMenu = Menu(Loc("Items", "items" :: "index" :: Nil, "List items"))
  
  // Build SiteMap
  val entries = Menu(Loc("Home", List("index"), "Home")) :: itemsMenu :: Nil
  

• 2- Define the default database
  The properties in src/main/resources/props/default.props with the connection url

  
  db.driver   = org.h2.Driver
  db.url      = jdbc:h2:~/hello_db
  db.user     =
  db.password =
  

  in src/main/scala/bootstrap/liftweb/Boot.scala

  
  
  DB.defineConnectionManager(DefaultConnectionIdentifier, DefaultDBVendor)
  Schemifier.schemify(true, Log.infoF _, Item)
  
  ...
  
  object DefaultDBVendor extends ConnectionManager {
      def newConnection(name: ConnectionIdentifier): Box[Connection] = {
          try {
              val connectionUrl = Props.get("db.url").openOr("") + "?user=" +
                                  Props.get("db.username").openOr("") + "&password=" +
                                  Props.get("db.password").openOr("")
  
              Class.forName(Props.get("db.driver").open_!)
              val dm = DriverManager.getConnection(connectionUrl)
              return Full(dm)
          }
          catch {
              case e: Exception => {
                  Log.error(e.getMessage);
                  return Empty
              }
          }
      }
  
      def releaseConnection(conn: Connection) = conn.close
  }
  
  

• 3- Create items/index.html
  in src/main/webapp/items/index.html

  
  <lift:surround with="default" at="content">
      <ul>
          <lift:adminItems.list>
              <li>
                  <item:name />
              </li>
          </lift:adminItems.list>
      </ul>
  </lift:surround>
  
  

  and snippet in src/main/scala/com/sample/snippet/AdminItems.scala

  
  package com.sample.snippet
  
  import scala.xml.{NodeSeq, Text}
  
  import net.liftweb.util.{Helpers, Log}
  import Helpers._
  
  import com.sample.model.Item
  
  class AdminItems {
  
      def list(node: NodeSeq): NodeSeq = {
          Item.findAll match {
              case Nil   => Text("There is no items in db")
              case items => items.flatMap(i => bind("item", node, "name" -> {i.name}))
          }
      }
  ...
  }
  

• 4- Add item form

  create a template for add/edit items in src/main/webapp/templates-hidden/item_form.html,
  we are going to use the same template for edit and add items,
  using TemplateFinder in AdminItems snippet

  
  <fieldset>
      <legend><itemForm:title /></legend>
      <label for="name">Name</label>
  
      <itemForm:name />
      <itemForm:id />
  
      <itemForm:submit />
  </fieldset>
  
  

  we are going to use two requestvars to decide when to display the edit form or the add form

  
      private object ShowAddItem  extends RequestVar[Int](0)
      private object SelectedItem extends RequestVar[Long](0)
  

  declare a showAddItem and showEditItem function in adminItems snippet

  
      def clear = {
          ShowAddItem(0)
          SelectedItem(0)
      }                  
  
      def showAddItem(node: NodeSeq): NodeSeq = {
          ShowAddItem.get match {
              case 1 => {
                  var name = ""
                  val template: NodeSeq = TemplateFinder.findAnyTemplate(ITEM_TEMPLATE :: Nil).openOr(<p></p>)
                  val content = bind("itemForm", template, "title"  -> Text("New item"),
                                                            "name"   -> SHtml.text(name, name = _),
                                                            "id"     -> Text(""),
                                                            "submit" -> SHtml.submit("save", () => addItem(name)),
                                                            "close"  -> SHtml.link("index", () => clear, Text("close")))                                                              
  
                  <div>{content}</div>
              }
              case _ => SHtml.link("index", () => ShowAddItem(1), <p>Add</p>)
          }
      }                                                                      
  
      def showEditItem(node: NodeSeq): NodeSeq = {
          if (SelectedItem.get > 0) {
              var id = SelectedItem.get
              val item = Item.find(id).open_!     
  
              var name = item.name.is
  
              val template = TemplateFinder.findAnyTemplate(ITEM_TEMPLATE :: Nil).openOr(<p></p>)
              val content  = bind("itemForm", template, "title"  -> Text("Edit item"),
                                                        "name"   -> SHtml.text(name, name = _),
                                                        "id"     -> Html.hidden(() => {id = id}),
                                                        "submit" -> SHtml.submit("save", () => saveItem(id, name)),
                                                        "close"  -> SHtml.link("index", () => clear, Text("close")))                                                                  
  
              <div>{content}</div>
          }
          else {
              <div></div>
          }
      }
  

  Now we can call the showEditItem and showAddItem snippets functions in items/index view

  
  <lift:surround with="default" at="content">
      <ul>
          <lift:adminItems.list>
              <li>
                  <item:name />
  
                  <item:edit />
                  <item:remove />
              </li>
          </lift:adminItems.list>
      </ul>
  
      <lift:adminItems.showAddItem  form="POST" />
      <lift:adminItems.showEditItem form="POST" />
  </lift:surround>
  
  

  The attribute form=”POST” on the snippet will create a form with method=”POST” automatically arround the snippet content.

  And that’s it, a simple list with liftweb.
  The code can be found on http://github.com/jgoday/sample_lift_testing

We can use dbunit to populate a sample database for testing purposes,
in this example we are going to use the embedded h2 database.

• 1. Create a sample liftweb (1.1-M8) application using maven 2.2

  
  mvn org.apache.maven.plugins:maven-archetype-plugin:2.0-alpha-4:generate        \
      -DarchetypeGroupId=net.liftweb        \
      -DarchetypeArtifactId=lift-archetype-blank        \
      -DarchetypeVersion=1.1-M8        \
      -DremoteRepositories=http://scala-tools.org/repo-releases        \
      -DgroupId=com.sample -DartifactId=hello
  
  

  And add the testing dependencies to pom.xml (specs, h2database and dbunit)

  
  
  <dependency>
      <groupId>org.scala-tools.testing</groupId>
      <artifactId>specs</artifactId>
      <version>1.4.4</version>
      <scope>test</scope>
  </dependency>                                 
  
  <dependency>
      <groupId>com.h2database</groupId>
      <artifactId>h2</artifactId>
      <version>1.2.125</version>
      <scope>test</scope>
  </dependency>                     
  
  <dependency>
      <groupId>org.dbunit</groupId>
      <artifactId>dbunit</artifactId>
      <version>2.4.7</version>
      <scope>test</scope>
  </dependency>
  
  

• 2. Create a sample model vo (Item with name and id)

  in src/main/scala/com/sample/model/Item.scala,
  a sample object with a string attribute name that cannot be empty.

  
  package com.sample.model
  
  import net.liftweb.mapper.{By, IdPK,
                             LongKeyedMapper, LongKeyedMetaMapper,
                             MappedString}
  
  class Item extends LongKeyedMapper[Item] with IdPK {
      def getSingleton = Item
  
      object name extends MappedString(this, 100) {
          override def validations = valMinLen(1, "Must be not empty") _ ::
                                     super.validations
      }
  }
  
  object Item extends Item with LongKeyedMetaMapper[Item] {
      def findByName(name: String): List[Item] = {
          Item.findAll(By(Item.name, name))
      }
  }
  
  

  We can test the compilation to let maven download the dependencies
  without testing : mvn package -Dmaven.test.skip=true

• 3. Create a sample Specs test file for item

  in src/test/scala/com/sample/model/ItemSpecs.scala,

  
  package com.sample.model
  
  import org.specs.Specification
  import org.specs.runner.JUnit4
  
  class ItemSpecsAsTest extends JUnit4(ItemSpecs)
  
  object ItemSpecs extends Specification {
      "Item" should {
          "do nothing wrong" in {
              true must beTrue
          }
      }
  }
  
  

• 4. Create a database util class to initialize database and populate data

  in src/test/scala/com/sample/utils/DBUtil.scala,

  it will initialize the default database connection identifier using the properties file in
  src/test/resources (by default src/test/resources/props/test.default.props)

  and will let us choose a dbunit dataset file to populate the test data using
  DBUtil.setupDB(“dbunit_database_file.xml”)

  
  package com.sample.utils                                                     
  
  import net.liftweb.mapper.{DB,
                            ConnectionIdentifier, DefaultConnectionIdentifier,
                            StandardDBVendor}
  import net.liftweb.util.{Log, Props}                                        
  
  import org.dbunit.dataset.{IDataSet}
  import org.dbunit.dataset.xml.{XmlDataSet}
  import org.dbunit.database.{DatabaseConfig, DatabaseConnection}
  import org.dbunit.operation.{DatabaseOperation}                
  
  object DBUtil {
      private var dataset: IDataSet      = null
      private var dbunitConnection: DatabaseConnection = null
  
      lazy val connectionIdentifier: () => ConnectionIdentifier = {
          () => DefaultConnectionIdentifier
      }                                                            
  
      def initialize = {
          DB.defineConnectionManager(connectionIdentifier(),
                                    new StandardDBVendor(Props.get("db.driver").openOr(""),
                                                         Props.get("db.url").openOr(""),
                                                         Props.get("db.user"),
                                                         Props.get("db.password")))
      }                                                                                    
  
      def setupDB(filename: String) = {
          this.dataset = new XmlDataSet(this.getClass().getClassLoader().getResourceAsStream(filename))
  
          DB.use(connectionIdentifier()) {
              conn => {
                  this.dbunitConnection = new DatabaseConnection(conn)
                  DatabaseOperation.CLEAN_INSERT.execute(this.dbunitConnection, this.dataset)
              }
          }
      }
  
      def shutdownDB = {
          DB.use(connectionIdentifier()) {
              conn => {
                  try {
                      DatabaseOperation.DELETE.execute(this.dbunitConnection, this.dataset)
                  }
                  catch {
                      case e: Exception => Log.error(e.getMessage)
                  }
              }
          }
  
      }
  }
  
  

• 5. Now we can do some more interesting test

  using a sample dataset in src/test/resources/dbunit/item_test.xml,
  the lift Shemifier class will create the database table on the beggining of the test
  and destroy it at the end.

  
  package com.sample.model                                                        
  
  import net.liftweb.mapper.{Schemifier}
  import net.liftweb.util.{Log}         
  
  import com.sample.utils.DBUtil
  
  import org.specs.Specification
  import org.specs.runner.JUnit4
  
  class ItemSpecsAsTest extends JUnit4(ItemSpecs)
  
  object ItemSpecs extends Specification {
      "Item" should {
          doFirst {
              DBUtil.initialize
              Schemifier.schemify(true, Log.infoF _ , Item)
              DBUtil.setupDB("dbunit/item_test.xml")
          }                                                
  
          "save without problem" in {
              val item = new Item
              item.name("item name")
  
              item.save must beTrue
              (Item.findAll.length == 3) must beTrue
          }
  
          "find by name" in {
              val items = Item.findByName("Item 1")
              items.length must_== 1
          }
  
          "delete without problem" in {
              val items = Item.findByName("item name")
  
              items.length must_== 1
              items(0).delete_! must beTrue
              Item.findAll.length must_== 2
          }
  
          doLast {
              DBUtil.shutdownDB
              Schemifier.destroyTables_!!(Log.infoF _, Item)
          }
      }
  }
  
  
  

Simple and funny

The sample code can be found in

http://github.com/jgoday/sample_lift_testing