alf-rack 0.15.0

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+# 0.15.0 / FIX ME
+
+* Enhancements
+
+  * Birthday!

data/Gemfile

@@ -0,0 +1,23 @@
+source 'http://rubygems.org'
+
+group :runtime do
+  gem "rack", "~> 1.5"
+  gem "rack-accept", "~> 0.4.5"
+  gem "ruby_cop", "~> 1.0"
+
+  gem "alf-core", path: "../alf-core"
+end
+
+group :development do
+  gem "rack-test", "~> 0.6.2"
+  gem "rake", "~> 10.1"
+  gem "path", "~> 1.3"
+  gem "rspec", "~> 2.14"
+  gem "sinatra", "~> 1.4"
+  gem "sqlite3", "~> 1.3",      :platforms => ['mri', 'rbx']
+  gem "jdbc-sqlite3", "~> 3.7", :platforms => ['jruby']
+  gem "sequel", "~> 4.2"
+
+  gem "alf-sql",    path: "../alf-sql"
+  gem "alf-sequel", path: "../alf-sequel"
+end

data/Gemfile.lock

@@ -0,0 +1,76 @@
+PATH
+  remote: ../alf-core
+  specs:
+    alf-core (0.15.0)
+      domain (~> 1.0)
+      myrrha (~> 3.0)
+      path (~> 1.3)
+      sexpr (~> 0.6.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-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)
+    rack (1.5.2)
+    rack-accept (0.4.5)
+      rack (>= 0.4)
+    rack-protection (1.5.1)
+      rack
+    rack-test (0.6.2)
+      rack (>= 1.0)
+    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.7)
+    rspec-expectations (2.14.3)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.14.4)
+    ruby_cop (1.0.5)
+    sequel (4.3.0)
+    sexpr (0.6.0)
+    sinatra (1.4.4)
+      rack (~> 1.4)
+      rack-protection (~> 1.4)
+      tilt (~> 1.3, >= 1.3.4)
+    sqlite3 (1.3.8)
+    tilt (1.4.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  alf-core!
+  alf-sequel!
+  alf-sql!
+  jdbc-sqlite3 (~> 3.7)
+  path (~> 1.3)
+  rack (~> 1.5)
+  rack-accept (~> 0.4.5)
+  rack-test (~> 0.6.2)
+  rake (~> 10.1)
+  rspec (~> 2.14)
+  ruby_cop (~> 1.0)
+  sequel (~> 4.2)
+  sinatra (~> 1.4)
+  sqlite3 (~> 1.3)

data/LICENCE.md

@@ -0,0 +1,22 @@
+# The MIT Licence
+
+    Copyright (c) 2013 - Bernard Lambeau
+
+    Permission is hereby granted, free of charge, to any person obtaining
+    a copy of this software and associated documentation files (the
+    "Software"), to deal in the Software without restriction, including
+    without limitation the rights to use, copy, modify, merge, publish,
+    distribute, sublicense, and/or sell copies of the Software, and to
+    permit persons to whom the Software is furnished to do so, subject to
+    the following conditions:
+
+    The above copyright notice and this permission notice shall be
+    included in all copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+    NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+    LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+    OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+    WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Manifest.txt

@@ -0,0 +1,12 @@
+rack.gemspec
+rack.noespec
+CHANGELOG.md
+Gemfile
+Gemfile.lock
+lib/**/*
+LICENCE.md
+Manifest.txt
+Rakefile
+README.md
+spec/**/*
+tasks/**/*

data/README.md

@@ -0,0 +1,58 @@
+# Alf::Rack
+
+[![Build Status](https://secure.travis-ci.org/alf-tool/alf-rack.png)](http://travis-ci.org/alf-tool/alf-rack)
+[![Dependency Status](https://gemnasium.com/alf-tool/alf-rack.png)](https://gemnasium.com/alf-tool/alf-rack)
+[![Code Climate](https://codeclimate.com/github/alf-tool/alf-sql.png)](https://codeclimate.com/github/alf-tool/alf-rack)
+
+A collection of Rack middlewares for using Alf in web applications.
+
+## Links
+
+* http://github.com/blambeau/alf
+* http://github.com/blambeau/alf-rack
+
+## Example: a RESTful-like interface
+
+**See the examples folder for more advanced examples.**
+
+```
+require 'sinatra'
+require 'alf-rack'
+
+# include some helpers (see later)
+include Alf::Rack::Helpers
+
+# This middleware will open a database connection on every request.
+# That connection and query methods are available through the helpers.
+use Alf::Rack::Connect do |cfg|
+  cfg.database = ::Sequel.connect("postgres://...")
+end
+
+# Let send all suppliers, automatically use HTTP_ACCEPT to encode in
+# requested format (csv, json, etc.)
+get '/suppliers' do |id|
+  Alf::Rack::Response.new{|r|
+    r.body = relvar{ suppliers }
+  end
+end
+
+# Similar for a single supplier tuple
+get '/suppliers/:id' do |id|
+  # Find the supplier
+  Alf::Rack::Response.new{|r|
+    r.body = tuple_extract{ restrict(suppliers, sid: id) }
+  end
+end
+```
+
+## Example: arbitrary queries
+
+```
+# As before
+use Alf::Rack::Connect do |cfg|
+  cfg.database = ::Sequel.connect("postgres://...")
+end
+
+# Answers arbitrary queries on POST /
+run Alf::Rack::Query.new
+```

data/Rakefile

@@ -0,0 +1,11 @@
+# We run tests by default
+task :default => :test
+
+#
+# Install all tasks found in tasks folder
+#
+# See .rake files there for complete documentation.
+#
+Dir["tasks/*.rake"].each do |taskfile|
+  load taskfile
+end

data/lib/alf-rack.rb

@@ -0,0 +1 @@
+require_relative "alf/rack"

data/lib/alf/rack.rb

@@ -0,0 +1,11 @@
+require_relative 'rack/version'
+require_relative 'rack/loader'
+module Alf
+  module Rack
+  end
+end
+require_relative 'rack/errors'
+require_relative 'rack/config'
+require_relative 'rack/connect'
+require_relative 'rack/helpers'
+require_relative 'rack/response'

data/lib/alf/rack/config.rb

@@ -0,0 +1,62 @@
+module Alf
+  module Rack
+    class Config < Support::Config
+
+      # The database instance to use for obtaining connections
+      option :database, Database, nil
+
+      # The connection options to use
+      option :connection_options, Hash, {}
+
+      # Enclose all requests in a single database transaction?
+      option :transactional, Boolean, false
+
+      # Sets the database, coercing it if required
+      def database=(db)
+        @database = db.is_a?(Database) ? db : Alf.database(db)
+      end
+
+      # Returns the default viewpoint to use
+      def viewpoint
+        connection_options[:viewpoint]
+      end
+
+      # Sets the default viewpoint on connection options
+      def viewpoint=(vp)
+        connection_options[:viewpoint] = vp
+      end
+
+    ### At runtime (requires having dup the config first)
+
+      # The current database connection
+      attr_reader :connection
+
+      # Connects to the database, starts a transaction if required, then
+      # yields the block with the connection object.
+      #
+      # The connection is kept under an instance variable and can be later
+      # obtained through the `connection` accessor. Do NOT use this method
+      # without having called `dup` on the config object as it relies on
+      # shared mutable state.
+      def connect(&bl)
+        return yield unless database
+        database.connect(connection_options) do |conn|
+          @connection = conn
+          if transactional?
+            conn.in_transaction{ yield(conn) }
+          else
+            yield(conn)
+          end
+        end
+      end
+
+      # Reconnect with new options. This method is provided if you want to
+      # use another viewpoint than the original one in the middle of the
+      # request treatment.
+      def reconnect(opts)
+        connection.reconnect(opts)
+      end
+
+    end # class Config
+  end # module Rack
+end # module Alf

data/lib/alf/rack/connect.rb

@@ -0,0 +1,45 @@
+module Alf
+  module Rack
+    # Connect to a database and make the connection available in the Rack
+    # environment.
+    #
+    # Example:
+    #
+    # ```
+    # require 'sinatra'
+    #
+    # use Alf::Rack::Connect do |cfg|  # see Alf::Rack::Config
+    #   cfg.database = ... # (required) a Alf::Database or Alf::Adapter
+    # end
+    #
+    # get '/' do
+    #   # the configuration object (a dup of what has been seen above)
+    #   config = env[Alf::Rack::Connect::CONFIG_KEY]
+    #
+    #   # the config object is connected
+    #   connection = config.connection
+    #   # => Alf::Database::Connection
+    #
+    #   # ...
+    # end
+    # ```
+    class Connect
+
+      CONFIG_KEY = "ALF_RACK_CONFIG".freeze
+
+      def initialize(app, config = Config.new)
+        @app    = app
+        @config = config
+        yield(config) if block_given?
+      end
+
+      def call(env)
+        env[CONFIG_KEY] = cfg = @config.dup
+        cfg.connect do
+          @app.call(env)
+        end
+      end
+
+    end # class Connect
+  end # module Rack
+end # module Alf

data/lib/alf/rack/errors.rb

@@ -0,0 +1,15 @@
+module Alf
+  module Rack
+
+    # Superclass of all Alf::Rack errors
+    class Error < StandardError; end
+
+    # Raised when Alf is unable to convert a tuple or relation into the
+    # requested mime type (HTTP_ACCEPT).
+    class AcceptError < Error; end
+
+    # Raised by the Query middleware when a query seems invalid.
+    class QueryError < StandardError; end
+
+  end # module Rack
+end # module Alf

data/lib/alf/rack/helpers.rb

@@ -0,0 +1,34 @@
+module Alf
+  module Rack
+    module Helpers
+
+      # Returns Alf configuration previously installed by the Connect
+      # middleware
+      def alf_config
+        env[Alf::Rack::Connect::CONFIG_KEY]
+      end
+
+      # Returns Alf's connection previously installed by the Connect
+      # middleware
+      def alf_connection
+        alf_config.connection
+      end
+
+      # Executes a query on the connection and returns the result.
+      def query(*args, &bl)
+        alf_connection.query(*args, &bl)
+      end
+
+      # Requests a relvar on the connection and returns it.
+      def relvar(*args, &bl)
+        alf_connection.relvar(*args, &bl)
+      end
+
+      # Requests a tuple on the connection and returns it.
+      def tuple_extract(*args, &bl)
+        alf_connection.tuple_extract(*args, &bl)
+      end
+
+    end # module Helpers
+  end # module Rack
+end # module Alf

data/lib/alf/rack/loader.rb

@@ -0,0 +1,3 @@
+require "rack"
+require "rack/accept"
+require "alf-core"

data/lib/alf/rack/query.rb

@@ -0,0 +1,148 @@
+require "ruby_cop"
+module Alf
+  module Rack
+    # This Rack application allows client to query your database by simply
+    # sending Alf queries as body of POST requests. It automatically run those
+    # queries on the current connection and encodes the result according to
+    # the HTTP_ACCEPT header.
+    #
+    # IMPORTANT: Alf has no true parser for now. In order to mitigate the risk
+    # of exposing serious attack vectors, you MUST take care of installing the
+    # safer parser on your database, as illustrated below. This seriously makes
+    # attacks harder, unfortunately without any guarantee...
+    #
+    # By default, this class catches all errors (e.g. syntax, type-checking
+    # security, runtime query execution) and return a 400 response with the
+    # error message. A side-effect is that all tuples are loaded in memory
+    # before returning the response, to ensure that any error is discovered
+    # immediately. When setting `catch_all` to false, this class sets a relvar
+    # instance as response body and let all errors percolate up the Rack stack.
+    # This means that errors may occur later, during actual query execution.
+    #
+    # Example:
+    #
+    # ```
+    # # in a config.ru or something
+    #
+    # # Create a database with a safer parser than usual
+    # require 'alf/lang/parser/safer'
+    # DB = Alf::Database.new(...){|opts|
+    #   opts.parser = Alf::Lang::Parser::Safer
+    # }
+    #
+    # Connect the database on every request
+    # use Alf::Rack::Connect{|cfg|
+    #   cfg.database = DB
+    # } 
+    #
+    # # let the query engine run under '/'
+    # run Alf::Rack::Query.new{|q|
+    #   q.type_check = false  # to bypass expressions type-checking
+    #   q.catch_all  = false  # to let errors percolate
+    # }
+    # ```
+    class Query
+      include Alf::Rack::Helpers
+
+      # Rack response when not found
+      NOT_FOUND = [404, {}, []]
+
+      # Recognized URLs
+      RECOGNIZED_URLS_RX = /^(\/(data|metadata|logical|physical)?)?$/
+
+      # Apply type checking (defaults to true)? 
+      attr_accessor :type_check
+      alias         :type_check? :type_check
+
+      # Catch all errors or let them percolate up the stack (default to true)?
+      attr_accessor :catch_all
+      alias         :catch_all? :catch_all
+
+      # Creates an application instance
+      def initialize
+        @type_check = true
+        @catch_all  = true
+        yield(self) if block_given?
+      end
+
+      # Call on a duplicated instance
+      def call(env)
+        return NOT_FOUND unless env['REQUEST_METHOD'] == 'POST'
+        return NOT_FOUND unless env['PATH_INFO'] =~ RECOGNIZED_URLS_RX
+        dup._call(env)
+      end
+
+      # Set the environment, execute the query and encode the response.
+      def _call(env)
+        @env = env
+        Alf::Rack::Response.new(env){|r|
+          safe(r){ execute }
+        }.finish
+      end
+      attr_reader :env
+
+    private
+
+      # Executes the block in a begin/rescue implementing the catch_all
+      # strategy
+      def safe(response)
+        result = yield
+        response.body = result
+      rescue => ex
+        raise unless catch_all?
+        response.status = 400
+        response.body = { "error" => "#{ex.class}: #{ex.message}" }
+      end
+
+      # Executes the request
+      def execute
+        case env['PATH_INFO']
+        when '', '/', '/data' then data
+        when '/metadata'      then metadata
+        when '/logical'       then logical_plan
+        when '/physical'      then physical_plan
+        end
+      end
+
+      def data
+        relvar(query).value
+      end
+
+      def metadata
+        q       = query
+        keys    = q.keys.to_a.map{|k| k.to_a }
+        heading = Relation(q.heading.to_hash.each_pair.map{|k,v|
+          {attribute: k, type: v.to_s}
+        })
+        {heading: heading, keys: keys}
+      end
+
+      def logical_plan
+        q = query
+        {
+          origin:    q.to_ascii_tree,
+          optimized: relvar(q).expr.to_ascii_tree
+        }
+      end
+
+      def physical_plan
+        q = query
+        {
+          plan: relvar(q).to_cog.to_ascii_tree
+        }
+      end
+
+      def query
+        query = env['rack.input'].read
+        query = alf_connection.parse(query)
+        if query.is_a?(Algebra::Operand)
+          query.type_check if type_check?
+          query
+        else
+          raise QueryError, "Not a relational expression"
+        end
+      end
+
+    end # class Query
+  end # module Rack
+end # module Alf