alf 0.14.0 → 0.15.0

data/Gemfile

@@ -1,9 +1,12 @@
 source 'http://rubygems.org'
 
 group :runtime do
-  gem "alf-core",   "~> 0.14.0"
-  gem "alf-sequel", "~> 0.14.0"
-  gem "alf-shell",  "~> 0.14.0"
+  gem "alf",        path: "."
+  gem "alf-core",   path: "./alf-core"
+  gem "alf-sql",    path: "./alf-sql"
+  gem "alf-shell",  path: "./alf-shell"
+  gem "alf-sequel", path: "./alf-sequel"
+  gem "alf-rack",   path: "./alf-rack"
 end
 
 group :test do

data/Gemfile.lock

@@ -1,44 +1,90 @@
-GEM
-  remote: http://rubygems.org/
+PATH
+  remote: .
+  specs:
+    alf (0.15.0)
+      alf-core (~> 0.15.0)
+      alf-rack (~> 0.15.0)
+      alf-sequel (~> 0.15.0)
+      alf-shell (~> 0.15.0)
+      alf-sql (~> 0.15.0)
+
+PATH
+  remote: ./alf-core
   specs:
-    alf-core (0.14.0)
+    alf-core (0.15.0)
       domain (~> 1.0)
       myrrha (~> 3.0)
       path (~> 1.3)
-      sexpr (~> 0.5.1)
-    alf-sequel (0.14.0)
-      alf-core (~> 0.14.0)
-      sequel (~> 3.48)
-    alf-shell (0.14.0)
-      alf-core (~> 0.14.0)
+      sexpr (~> 0.6.0)
+
+PATH
+  remote: ./alf-rack
+  specs:
+    alf-rack (0.15.0)
+      alf-core (~> 0.15.0)
+      rack (~> 1.5)
+      rack-accept (~> 0.4.5)
+      ruby_cop (~> 1.0)
+
+PATH
+  remote: ./alf-sequel
+  specs:
+    alf-sequel (0.15.0)
+      alf-core (~> 0.15.0)
+      alf-sql (~> 0.15.0)
+      sequel (~> 4.2)
+
+PATH
+  remote: ./alf-shell
+  specs:
+    alf-shell (0.15.0)
+      alf-core (~> 0.15.0)
       quickl (~> 0.4.3)
+
+PATH
+  remote: ./alf-sql
+  specs:
+    alf-sql (0.15.0)
+      alf-core (~> 0.15.0)
+      sexpr (~> 0.6.0)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
     diff-lcs (1.2.4)
     domain (1.0.0)
     myrrha (3.0.0)
       domain (~> 1.0)
     path (1.3.3)
-    pg (0.14.1)
+    pg (0.17.0)
     quickl (0.4.3)
+    rack (1.5.2)
+    rack-accept (0.4.5)
+      rack (>= 0.4)
     rake (10.1.0)
     rspec (2.14.1)
       rspec-core (~> 2.14.0)
       rspec-expectations (~> 2.14.0)
       rspec-mocks (~> 2.14.0)
-    rspec-core (2.14.4)
-    rspec-expectations (2.14.0)
+    rspec-core (2.14.7)
+    rspec-expectations (2.14.3)
       diff-lcs (>= 1.1.3, < 2.0)
-    rspec-mocks (2.14.1)
-    sequel (3.48.0)
-    sexpr (0.5.1)
-    sqlite3 (1.3.7)
+    rspec-mocks (2.14.4)
+    ruby_cop (1.0.5)
+    sequel (4.3.0)
+    sexpr (0.6.0)
+    sqlite3 (1.3.8)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
-  alf-core (~> 0.14.0)
-  alf-sequel (~> 0.14.0)
-  alf-shell (~> 0.14.0)
+  alf!
+  alf-core!
+  alf-rack!
+  alf-sequel!
+  alf-shell!
+  alf-sql!
   jdbc-sqlite3 (~> 3.7)
   pg (~> 0.14)
   rake (~> 10.1)

data/README.md

@@ -7,190 +7,84 @@ Relational Algebra at your fingertips
 
 ## Links
 
-* [Official documentation](http://blambeau.github.com/alf)
+* [Try it online](http://www.try-alf.org/)
+* [Official documentation](http://www.try-alf.org/doc/)
+* [Blog](http://www.try-alf.org/blog/)
 * [Source and Issues](http://github.com/alf-tool/alf)
-* [Relational basics as needed](http://www.revision-zero.org/relational-basics-2)
-
-## What & Why
-
-Alf brings the relational algebra both in Shell and in Ruby. In Shell, because
-manipulating any relation-like data source should be as straightforward as a one-liner.
-In Ruby, because I've never understood why programming languages provide data structures
-like arrays, hashes, sets, trees and graphs but not _relations_...
-
-## Shell Example
-
-    % alf --examples show suppliers
-
-    +------+-------+---------+--------+
-    | :sid | :name | :status | :city  |
-    +------+-------+---------+--------+
-    | S1   | Smith |      20 | London |
-    | S2   | Jones |      10 | Paris  |
-    | S3   | Blake |      30 | Paris  |
-    | S4   | Clark |      20 | London |
-    | S5   | Adams |      30 | Athens |
-    +------+-------+---------+--------+
-
-    % alf --examples group suppliers -- size name status -- in_that_city
-
-    +--------+----------------------------+
-    | :city  | :in_that_city              |
-    +--------+----------------------------+
-    | London | +------+-------+---------+ |
-    |        | | :sid | :name | :status | |
-    |        | +------+-------+---------+ |
-    |        | | S1   | Smith |      20 | |
-    |        | | S4   | Clark |      20 | |
-    |        | +------+-------+---------+ |
-    | Paris  | +------+-------+---------+ |
-    |        | | :sid | :name | :status | |
-    |        | +------+-------+---------+ |
-    |        | | S2   | Jones |      10 | |
-    |        | | S3   | Blake |      30 | |
-    |        | +------+-------+---------+ |
-    | Athens | +------+-------+---------+ |
-    |        | | :sid | :name | :status | |
-    |        | +------+-------+---------+ |
-    |        | | S5   | Adams |      30 | |
-    |        | +------+-------+---------+ |
-    +--------+----------------------------+
-
-## Ruby Example
-
-    # Let get the same database in ruby
-    db  = Alf.examples
-
-    # Group suppliers by city
-    grouped = db.query{
-      group(:suppliers, [:sid, :name, :status], :in_that_city)
-    }
-    # => same result as in shell
-
-    # Let make some computations on the sub-relations
-    db.query{
-      extend(grouped, how_many:   ->{ in_that_city.count },
-                      avg_status: ->{ in_that_city.avg{ status } })
-    }
-    # +--------+----------------------------+-----------+-------------+
-    # | :city  | :in_that_city              | :how_many | :avg_status |
-    # +--------+----------------------------+-----------+-------------+
-    # | London | +------+-------+---------+ |         2 |      20.000 |
-    # |        | | :sid | :name | :status | |           |             |
-    # |        | +------+-------+---------+ |           |             |
-    # |        | | S1   | Smith |      20 | |           |             |
-    # |        | | S4   | Clark |      20 | |           |             |
-    # |        | +------+-------+---------+ |           |             |
-    # | Paris  | +------+-------+---------+ |         2 |      20.000 |
-    # |        | | :sid | :name | :status | |           |             |
-    # |        | +------+-------+---------+ |           |             |
-    # |        | | S2   | Jones |      10 | |           |             |
-    # |        | | S3   | Blake |      30 | |           |             |
-    # |        | +------+-------+---------+ |           |             |
-    # | Athens | +------+-------+---------+ |         1 |      30.000 |
-    # |        | | :sid | :name | :status | |           |             |
-    # |        | +------+-------+---------+ |           |             |
-    # |        | | S5   | Adams |      30 | |           |             |
-    # |        | +------+-------+---------+ |           |             |
-    # +--------+----------------------------+-----------+-------------+
-
-    # Now observe that the same result can also be expressed as follows (and can be
-    # optimized more easily)
-    summarized = db.query{
-      summary = summarize(:suppliers, [ :city ], how_many: count, avg_status: avg{ status })
-      join(grouped, summary)
-    }
-
-    # Oh, and of course...
-    require 'json'
-    puts summarized.to_json
-    # [{"city":"London","in_that_city":[{"sid":"S1","name":"Smith","status":20},{"sid":"S4"...
-
-## Install, bundler, require
-
-    % [sudo] gem install alf [fastercsv, ...]
-    % alf --help
-
-    # API is not considered stable enough for now, please use
-    gem "alf", "= 0.13.0"
-
-    # The following should not break your code, but is a bit less safe,
-    # until 1.0.0 has been reached
-    gem "alf", "~> 0.13.0"
-
-## Related Work & Tools
-
-- You should certainly have a look at the
-  [Third Manifesto website](http://www.thethirdmanifesto.com/):
-- Why not reading the
-  [third manifesto](http://www.dcs.warwick.ac.uk/~hugh/TTM/DBE-Chapter01.pdf) ?
-- Also have a look at
-  [other implementation projects](http://www.dcs.warwick.ac.uk/~hugh/TTM/Projects.html)
-  especially [Rel](http://dbappbuilder.sourceforge.net/Rel.php) which provides an
-  implementation of the **Tutorial D** language.
-- [Dan Kubb's Veritas](https://github.com/dkubb/veritas) project is worth considering
-  also in the Ruby community. While very similar to Alf in providing a pure ruby
-  algebra implementation, Veritas mostly provides a framework for manipulating
-  and statically analyzing algebra expressions so as to be able to
-  [optimize them](https://github.com/dkubb/veritas-optimizer) and
-  [compile them to SQL](https://github.com/dkubb/veritas-sql-generator).
+
+## Overview
+
+Alf is a modern query language, rooted in relational algebra, and implemented
+as a Ruby Domain Specific Language. It is distributed as a consolidated ruby
+gem:
+
+```
+gem install alf
+```
+
+You'll also need the usual adapter gems for connecting to SQL engines, such as
+`pg` for PostgreSQL or `sqlite3` for SQlite. I've not tested Alf against MySQL
+and won't.
+
+See the official documentation for getting started using Alf
+[in Ruby](http://www.try-alf.org/doc/pages/alf-in-ruby) and
+[in Shell](http://www.try-alf.org/doc/pages/alf-in-shell).
+
+## Detailed overview
+
+The consolidated gem is assembled from the following components:
+
+* [alf-core](http://github.com/alf-tool/alf-core) core classes of Alf,
+  algebra, memory engine, Relation, compiler, and so on. This is actually Alf
+  itself, I would say.
+* [alf-sql](http://github.com/alf-tool/alf-sql) extension of core's compiler
+  to handle SQL compilation specifically, in an abstract way.
+* [alf-sequel](http://github.com/alf-tool/alf-sequel) an adapter for
+  connecting to SQL DBMSs using [Sequel](http://sequel.rubyforge.org/).
+* [alf-shell](http://github.com/alf-tool/alf-shell) implements the commandline
+  tool that you can use without even knowing ruby.
+* [alf-rack](http://github.com/alf-tool/alf-rack) a few Rack middlewares for
+  using Alf in ruby web applications.
+* [alf-doc](http://github.com/alf-tool/alf-doc) is the source of all the
+  documentation found in man pages (shell) and on [try-alf.org](http://www.try-alf.org/).
+* [try-alf](http://github.com/alf-tool/try-alf) is the source code of try-alf.org
+  itself.
+
+Those components are distributed as separated ruby gems as well. A typical
+ruby configuration (Gemfile) for using Alf and connecting to SQL databases is
+either:
+
+```
+# consolidated gem, possibly with a lot of uneeded dependencies.
+gem "alf", "~> 0.15.0"
+```
+
+or
+
+```
+# take only those gems that you need, here for a web app connecting to SQL
+# databases.
+gem "alf-core", "~> 0.15.0"   # you can even omit this one
+gem "alf-sequel", "~> 0.15.0"
+gem "alf-rack", "~> 0.15.0"
+```
 
 ## Contributing
 
-You know the rules:
-
-* The code is on github https://github.com/blambeau/alf
-* Please report any problem or bug in the issue tracker on github
-* Don't hesitate to fork and send me a pull request for any contribution/idea!
-
-Alf is distributed under a MIT licence. Please let me know if it does not fit
-your needs and I'll see what I can do!
-
-## Roadmap
-
-Below is what I've imagined about Alf's future. However, this is to be interpreted
-as my own wish list, while I would love hearing yours instead.
-
-- Towards 1.0.0, I would like to stabilize and document Alf public APIs as well
-  as internals (a few concepts are still unstable there). Alf also has a certain
-  number of limitations that are worth overcoming for version 1.0.0. The latter
-  include the semantically wrong way of applying joins on sub-relations, the
-  impossibility to use Lispy expressions on sub-relations in extend, and the error
-  management which is unspecific and unfriendly so far.
-- I also would like starting collecting  Reader, Renderer and Connection
-  contributions for common data sources (SQL, NoSQL, CSV, LOGS) and output
-  formats (HTML, XML, JSON). Contributions could be either developped as different
-  gem projects or distributed with Alf's gem and source code, I still need to
-  decide the exact policy (suggestions are more than welcome here)
-- Alf will remain a practical tool before everything else. In the middle term,
-  I would like to complete the set of available operators (relational and non-
-  relational ones). Some of them will be operators described in D & D books
-  while others will be new suggestions of mine.
-- In the long term Alf should be able to avoid loading tuples in memory (under
-  a certain number of conditions on datasources) for almost all queries.
-- Without targetting a fast tool at all, I also would like Alf to provide a basic
-  optimizer that would be able to push equality restrictions down and materialize
-  sub-expressions used more than once in with expressions.
-
-## Versioning policy
-
-Alf respects [semantic versioning](http://semver.org/), which means that it has
-a X.Y.Z version number and follows a few rules.
-
-- The public API is made of the commandline tool, the Lispy dialect and the
-  Relation datastructure. This API will become stable with version 1.0.0 in a
-  near future.
-- Currently, version 1.0.0 **has not been reached**. It means that **anything
-  may change at any time**. Best effort will be done to upgrade Y when backward
-  incompatible changes occur.
-- Once 1.0.0 will be reached, the following rules will be followed:
-  - Backward compatible bug fixes will increase Z.
-  - New features and enhancements that do not break backward compatibility of
-    the public API will increase the Y number.
-  - Non backward compatible changes of the public API will increase the X
-    number.
-
-All classes and modules but Alf module, the Lispy DSL and Alf::Relation are part
-of the private API and may change at any time. A best-effort strategy is followed
-to avoid breaking internals on tiny (Z) version increases, especially extension
-points like Reader and Renderer.
+As usual, on github, issues and pull requests, either on sub-projects (if you
+know where your issue/contribution fits) or on this one (if you don't).
+
+Integration work on Alf requires having all components available. The scenario
+below might be a good way for getting started:
+
+```
+git clone git://github.com/alf-tool/alf.git
+git submodule init
+git submodule update
+rake mod:test
+rake test
+```
+
+Let me know if some tests fail in your environment. I'm not sure to know the
+idiomatic way to use github with submodules when clones are involved. If you
+do know, feel free to contribute your first pull request on this README ;-)

data/Rakefile

@@ -1,6 +1,31 @@
 # We run tests by default
 task :default => :test
 
+SUB_MODULES = %w[
+  core
+  sql
+  sequel
+  shell
+  rack
+  doc
+  rest
+]
+
+def clean_env(&bl)
+  Bundler.with_clean_env(&bl)
+end
+
+def in_each_sub_module(msg)
+  clean_env do
+    SUB_MODULES.each do |sub|
+      chdir("alf-#{sub}") do
+        puts "#{msg} #{sub}"
+        yield(sub)
+      end
+    end
+  end
+end
+
 #
 # Install all tasks found in tasks folder
 #

data/alf.gemspec

@@ -125,9 +125,11 @@ Gem::Specification.new do |s|
   #
   s.add_development_dependency("rake", "~> 10.1")
   s.add_development_dependency("rspec", "~> 2.14")
-  s.add_dependency("alf-core", "~> 0.14.0")
-  s.add_dependency("alf-sequel", "~> 0.14.0")
-  s.add_dependency("alf-shell", "~> 0.14.0")
+  s.add_dependency("alf-core", "~> 0.15.0")
+  s.add_dependency("alf-sql", "~> 0.15.0")
+  s.add_dependency("alf-sequel", "~> 0.15.0")
+  s.add_dependency("alf-shell", "~> 0.15.0")
+  s.add_dependency("alf-rack", "~> 0.15.0")
 
   # The version of ruby required by this gem
   #

data/alf.noespec

@@ -6,9 +6,9 @@ template-info:
       safe-override: false
     tasks/spec_test.rake:
       ignore: true
-    spec/spec_helper:
+    spec/spec_helper.rb:
       ignore: true
-    spec/test_alf:
+    spec/test___lower__.rb:
       ignore: true
 variables:
   lower:
@@ -16,7 +16,7 @@ variables:
   upper:
     Alf
   version:
-    0.13.0
+    0.15.0
   summary: |-
     Relational Algebra at your fingertips
   description: |-
@@ -29,8 +29,10 @@ variables:
     - http://rubygems.org/gems/alf
     - http://rubydoc.info/gems/alf
   dependencies:
-    - {name: alf-core,   version: "~> 0.14.0", groups: [runtime]}
-    - {name: alf-sequel, version: "~> 0.14.0", groups: [runtime]}
-    - {name: alf-shell,  version: "~> 0.14.0", groups: [runtime]}
+    - {name: alf-core,   version: "~> 0.15.0", groups: [runtime]}
+    - {name: alf-sql,    version: "~> 0.15.0", groups: [runtime]}
+    - {name: alf-sequel, version: "~> 0.15.0", groups: [runtime]}
+    - {name: alf-shell,  version: "~> 0.15.0", groups: [runtime]}
+    - {name: alf-rack,   version: "~> 0.15.0", groups: [runtime]}
     - {name: rake,       version: "~> 10.1",   groups: [test, release]}
     - {name: rspec,      version: "~> 2.14",   groups: [test, release]}