Planet Scala

A minor release of shapeless. The main changes include,

• Scrap Your Boilerplate improvements

  • Data and DataT instances for any type with an associated HListIso, allowing any case class to be traversed/transformed with just the addition of a single one-line implicit declaration
  • Data and DataT instances for pairs generalized to arbitrary tuples
  • Added a SYB example which also illustrates the gains from using HListIso
• Generalized toHList to anything viewable as a GenTraversable[_].
• Added HList toArray.
• Added infrastructure for lifting monomorphic functions to Poly1 and extending Poly1 domains to be universal.
• HList unify and toList now properly handle empty HLists.

Permalink

core

• Support X-Http-Method-Override header.
• Support mounting handlers by class as well as instance.
• Support ActionResult class hierarchy to bundle status, headers, and body into one case class.
• Returning an Int sets the status, just like Sinatra.
• CsrfTokenSupport recognizes the 'X-CSRF-Token' header.
• Cross build dropped from artifact ID. The same build runs for all Scala 2.9.x.
• Dropped support for Scala 2.8.x.

fileupload

• Deprecated in favor of native servlet handling. (Jetty users: requires >= 8.1.3.)
• Exceptions now handled through standard error handler.

swagger

• Support for route documentation with Swagger

test

• Support for testing multipart requests.

Permalink

SIP-18 is a bad idea because it makes awful assumptions about what is in the interest of language newcomers. I have had no shortage of unsolicited advice of how to teach, most of it in layers of wrongness, so I am acutely aware of the sheer quantity of this kind of advice. Please refrain for now. This is only my opinion, because it has been asked of me more than twice.

SIP-18 (and the Scala collections library for that matter) is no different to Haskell’s (dreaded) monomorphism restriction (DMR). The DMR was introduced specifically because of another chronically bold over-estimate of one’s ability to understand the process of learning. It is now an undesired language issue that hinders all users, especially newcomers. In other words, it serves nobody’s interest, hinders everyone’s interest and especially, the interest of those for whom it was meant to serve. You need only spend a short period of time with newcomers to Haskell to be overwhelmed by the prominence of this fact.

I can hear the pragmatists in the background muttering something about trade-offs, not being so extreme and keeping it relevant to the real world and blah blah blah, <insert the usual pragmatist bullshit here>. There is nothing to be traded off when you offer to take $5 from me for the low cost of $10. Now stop it and get your head out of the clouds so I can talk to you sensibly.

Not only does SIP-18 not help newcomers at all, it helps nobody, hinders everybody and especially newcomers. It is not a trade-off, it is not a good idea; it is simply a bold, severely misguided assertion about how learning takes place — it’s not even an approximation. I have seen only scant pseudo-psychology to support its existence, which obviates its predictable failure.

Hopefully, the Scala guys will work this out, but if Scala’s remarkable precision to repeat historical mistakes is anything to go by, I do not hold high hopes.

Thanks for asking.

A few days back the Scala IDE team released an early preview of the Scala IDE V2.1 for Eclipse, based on the new milestone (M3) for the upcoming Scala 2.10. This release has all the new features in the Scala IDE M1, plus a few minor changes needed in order to support 2.10.

You can see the Release Notes for M1 to check the new features in the Scala IDE, and the Scala Change Log for what’s new in Scala 2.10. Read more...

Syntax

Type Inference

Subtyping

Modules vs Objects

Typeclasses vs Implicit Parameters

Lazy vs Strict Evaluation

Type Safety

Development Environment

Runtime System

Performance

Final Words

This is a feature release, adding a the full set of useful XPath Axe, string based XPath evaluation - via a popular open source XPath library, useful equality testing, a lot of new documentation and many smaller improvements in syntax and usability.

This version has been built with xsbt 0.11.x and migrated to github. This releases documentation can be found here and provides many examples on how to use Scales Xml.

All the Axe you'll ever need

Scales 0.3 adds the following axe:

• preceding-sibling (preceding_sibling_::)
• following-sibling (following_sibling_::)
• descendant (descendant_::)
• following (following_::)
• preceding (preceding_::)
• ancestor (ancestor_::)
• ancestor-or-self (ancestor_or_self_::)
• descendant-or-self (descendant_or_self_::)

This provides all of the XPath 1 and 2 axe (namespace axis excluded).

Enhanced internal XPath queries

• position() (pos)

  pos\_<, pos\_==, pos\_>

• last() (last)

  last\_<, last\_==, last\_>

• position() == last() (pos_eq_last)

• Easier to extend and re-use queries and axe

  xfilter, xmap, xflatMap

String base XPath evaluation

• Evaluate normal XPath 1.0 strings to XmlPaths
• Evaluates to an Iterable[Either[AttributePath, XmlPath]] or,
• get[T] a value directly from XPath 1.0 (e.g. get[String]("normalize(//*)"))
• Allows querying for the few predicates and XPaths that Scales cannot process (and dynamic queries of course)
• Optional dependency

New xpath.Functions

• Unified interface for XPath function handling
• text, QName and Boolean typeclasses

• Implementations for all relevant Scales Xml types

  • string( attribute ) makes sense whilst string( QName ) does not

New XmlComparison framework (2.9.x only)

• Compare Xml structures and types
• Customisable comparison rules
• Default Scalaz === Equal type classes

• XmlComparison type classes provide full details of differences:

  • A QName based path to the difference
  • The objects which are different

Extra Fun

• Forwards and Backwards Path Iterators (used by following and preceding)
• DuplicateFilter now works with the Scalaz Equal typeclass
• Using AttributeQNames with the tuple arrow now creates QNames as you'd expect
• DslBuilder allows direct manipulation of trees via folding
• Simplify the Builder usage why /(<(Elem(... ) when you can just /(Elem)?
• Java 1.7 JAXP implementation checks - Schema validation is optimised (no serialization)

How To Use

Scales 0.3 moves to Sonatype under the organisation org.scalesxml, with support for 2.8.1, 2.8.2, 2.9.1 and 2.9.2. As such add:

libraryDependencies ++= Seq(
  // just for the core library
  "org.scalesxml" %% "scales-xml" % "0.3-RC6"
  // or, use this instead for String based XPaths (Jaxen, also includes the core)
  "org.scalesxml" %% "scales-jaxen" % "0.3-RC6"
)

to your xsbt builds or use scales-xml_2.9.2 as the id when using Maven.

Permalink

Minor enhancements

• sbt 0.11.3
• Adds buildInfoBuildNumber. #2

Permalink

minor enhancements

• sbt 0.11.3
• more default exclusions and merges contributed by @rjmac

Permalink

• Revamp command-line tool with more intuitive behaviour
• Add --quiet, --recurse, --stdin, --stdout options to command-line tool
• FIX: Scaladoc comment formatting could break nested comments (issue #36)
• Tidy up, optimise lexer code
• FIX: Parse 5.f, 5.d as floating points, unless in Scala 2.11+ mode
• FIX: Bug with line-per-annotation style
• Add support for String interpolation
• Add support for macros
• Add --scalaVersion=<version> flag to command-line tool
• Support expr[T1, T2][T3, T4] and g()[String] syntaxes
• Fix AST selection for prefix expression

Permalink

Small maintenance release, including:

• When loading a configuration from the classpath, a FileNotFoundException is thrown (issue #8) -- Martin Konicek
• Looking for a non existing key will throw a NoSuchElementException with a message clearly refering to the missing key (issue #11) -- Jussi Virtanen
• List values are sanitized by adding quotes when needed (issue #12)
• Artefacts for Scala 2.9.2

If you wish for extra features, feel free to ask.

Permalink

New Features

Multipart POST support for Netty

This substantial contribution by g-eorge handles file of uploads of arbitrary size, as previously supported only for filter plans. See the netty-uploads readme for details.

Migration Note: If you were using the unfiltered-uploads module before, you should now depend on unfiltered-filter-uploads. The former now serves as a base implementation for the filter and netty upload modules.

Kits

• unfiltered.kit.Secure redirects HTTP requests to HTTPS.
• unfiltered.kit.Auth requires basic auth for matching requests.
• unfiltered.kit.AsyncCycle — removed this promise/future-aware kit for the time being

Extractors

• unfiltered.request.QueryParams allows access to query-string parameters exclusively, doesn't read in the request body for POST params
• unfiltered.request.Charset The existing extractor yielded both the charset string as well as an HttpRequest object in the older fashion of Unfiltered. This is altered to now only yield the charset, which is a breaking change. If you see a compilation error for a Charset matcher, simply remove the trailing prameter in its parameter list.
• unfiltered.request.{Accept,AcceptCharset,AcceptEncoding,AcceptLanguage} all behave more correctly thanks to hamnis's content negotiation fixes.

Response Functions

• Support for rfc6585, additional status codes

Fixes

• Issue 110 Keymanagers loaded redundantly for Netty bindings
• Issue 111 TLS contexts created redudantly for Netty bindings
• Issue 119 NoSuchElementException for parameterValues
• Issue 123 Find path suffix only from path part of uri
• Issue 126 Tiny fix in url generation for Jetty Https Server

Permalink

flatMap Oslo (May 15, 16) is Norway’s first Scala conference, and the first anywhere to have such exciting light fixtures. (Good speaker lineup, too.)

Examples of Java calling Oracle PLSQL anonymous blocks

Why would you do this? Answer: Developement agility

  
import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Types;

public class CallPLSQLBlockWithOneInputStringAndOneOutputStringParameter {

    // Warning: this is a simple example program : In a long running application,
    // exception handlers MUST clean up connections statements and result sets.
    public static void main(String[] args) throws SQLException {

     DriverManager.registerDriver(new oracle.jdbc.OracleDriver());

        final Connection c = DriverManager.getConnection("jdbc:oracle:thin:@localhost:1521:XE", "system", "manager");
  String plsql = "" +
  " declare " +  
  "      p_id varchar2(20) := null; " +
  " begin " +
  "    p_id := ?; " +
  "    ? := 'input parameter was = ' || p_id;" +
  " end;";
        CallableStatement cs = c.prepareCall(plsql);
  cs.setString(1, "12345");
  cs.registerOutParameter(2, Types.VARCHAR);
  cs.execute();
  
  System.out.println("Output parameter was = '" + cs.getObject(2) + "'");
  
  cs.close();
        c.close();
    }
}

import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Types;

import oracle.jdbc.OracleTypes;

public class CallPLSQLBlockWithOneInputStringAndOneOutputStringParameterAndOneOutputCursorParameter {

    public static void main(String[] args) throws Exception {

     DriverManager.registerDriver(new oracle.jdbc.OracleDriver());
     
        final Connection c = DriverManager.getConnection("jdbc:oracle:thin:@localhost:1521:XE", "system", "manager");
  String plsql = "" +
  " declare " +  
  "    p_id varchar2(20) := null; " +
  "  l_rc sys_refcursor;" +
  " begin " +
  "    p_id := ?; " +
  "    ? := 'input parameter was = ' || p_id;" +
  "    open l_rc for " +
  "        select 1 id, 'hello' name from dual " +
  "        union " +
  "        select 2, 'peter' from dual; " +
  "    ? := l_rc;" +
  " end;";

        CallableStatement cs = c.prepareCall(plsql);
  cs.setString(1, "12345");
  cs.registerOutParameter(2, Types.VARCHAR);
  cs.registerOutParameter(3, OracleTypes.CURSOR);
  
  cs.execute();
  
  System.out.println("Result = " + cs.getObject(2));
  
  ResultSet cursorResultSet = (ResultSet) cs.getObject(3);
  while (cursorResultSet.next ())
  {
   System.out.println (cursorResultSet.getInt(1) + " " + cursorResultSet.getString(2));
  } 
  cs.close();
        c.close();
    }
}   

import java.sql.Array;
import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Types;

import oracle.jdbc.OracleTypes;
import oracle.sql.ARRAY;
import oracle.sql.ArrayDescriptor;

public class CallPLSQLBlockWithOneInputStringArrayAndOneOutputStringParameterAndOneOutputCursorParameter {

    public static void main(String[] args) throws Exception {

     DriverManager.registerDriver(new oracle.jdbc.OracleDriver());
     
        // Warning: this is a simple example program : In a long running application,
        // error handlers MUST clean up connections statements and result sets.
     
        final Connection c = DriverManager.getConnection("jdbc:oracle:thin:@localhost:1521:XE", "system", "manager");
  String plsql = "" +
  " declare " +  
  "    p_id string_array := null; " +
  "  l_rc sys_refcursor;" +
  " begin " +
  "    p_id := ?; " +
  "    ? := 'input parameter first element was = ' || p_id(1);" +
  "    open l_rc for select * from table(p_id) ; " +
  "    ? := l_rc;" +
  " end;";

  String[] stringArray = new String[]{ "mathew", "mark"};
  
  // MUST CREATE THIS IN ORACLE BEFORE RUNNING
  System.out.println("(This should be done once in Oracle)");
  c.createStatement().execute("create or replace type string_array is table of varchar2(32)");
  
  ArrayDescriptor descriptor = ArrayDescriptor.createDescriptor( "STRING_ARRAY", c );
  
  Array array_to_pass = new ARRAY( descriptor, c, stringArray );
  
  CallableStatement cs = c.prepareCall(plsql);
  cs.setArray( 1, array_to_pass );
  cs.registerOutParameter(2, Types.VARCHAR);
  cs.registerOutParameter(3, OracleTypes.CURSOR);
  
  cs.execute();
  
  System.out.println("Result = " + cs.getObject(2));
  
  ResultSet cursorResultSet = (ResultSet) cs.getObject(3);
  while (cursorResultSet.next ())
  {
   System.out.println (cursorResultSet.getString(1));
  } 
  cs.close();
        c.close();
    }
}  

import java.sql.Array;
import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Types;

import oracle.jdbc.OracleTypes;
import oracle.sql.ARRAY;
import oracle.sql.ArrayDescriptor;
import oracle.sql.STRUCT;
import oracle.sql.StructDescriptor;

public class CallPLSQLBlockWithOneInputStructureArrayAndOneOutputStringParameterAndOneOutputCursorParameter {

    public static void main(String[] args) throws Exception {

     DriverManager.registerDriver(new oracle.jdbc.OracleDriver());
     
        // Warning: this is a simple example program : In a long running application,
        // error handlers MUST clean up connections statements and result sets.
     
        final Connection c = DriverManager.getConnection("jdbc:oracle:thin:@localhost:1521:XE", "system", "manager");
  String plsql = "" +
  " declare " +  
  "    p_id student_array := null; " +
  "  l_rc sys_refcursor;" +
  " begin " +
  "    p_id := ?; " +
  "    ? := 'input parameter first element was = (' || p_id(1).id_num || ', ' || p_id(1).name || ')'; " +
  "    open l_rc for select * from table(p_id) ; " +
  "    ? := l_rc;" +
  " end;";

  
  // MUST CREATE ORACLE TYPES BEFORE RUNNING
  setupOracleTypes(c);
  
  StructDescriptor structDescr = StructDescriptor.createDescriptor("STUDENT", c);
  STRUCT s1struct = new STRUCT(structDescr, c, new Object[]{1, "mathew"});
  STRUCT s2struct = new STRUCT(structDescr, c, new Object[]{2, "mark"});
  ArrayDescriptor arrayDescr = ArrayDescriptor.createDescriptor( "STUDENT_ARRAY", c );
  Array array_to_pass = new ARRAY( arrayDescr, c, new Object[]{s1struct, s2struct} );
  
  CallableStatement cs = c.prepareCall(plsql);
  cs.setArray( 1, array_to_pass );
  cs.registerOutParameter(2, Types.VARCHAR);
  cs.registerOutParameter(3, OracleTypes.CURSOR);
  
  cs.execute();
  
  System.out.println("Result = " + cs.getObject(2));
  
  ResultSet cursorResultSet = (R