alf 0.12.2 → 0.13.0

data/examples/logs/combined.alf

@@ -1,2 +0,0 @@
-path = File.join(File.dirname(__FILE__), "access.log")
-Alf::Reader.reader(path, :file_format => [:apache, :combined])

data/examples/logs/hits.alf

@@ -1,14 +0,0 @@
-#
-# Give, for each page (path), the number of successfully (http status = 200) 
-# served requests. Take only non robot requests into account.
-#
-# Use the following invocation to have them sorted by hit number:
-# 
-#   alf --text --env=examples/logs sort hits -- hits asc
-#
-(summarize \
-  (restrict :combined, 
-            lambda{ (http_status == 200) and 
-                    not(user_agent =~ /[Bb]ot/ or path =~ /robots.txt/) }),
-  [:path],
-  :hits   => count())

data/examples/logs/not_found.alf

@@ -1,7 +0,0 @@
-#
-# Give all paths (together with http method and version) for which a 404 not 
-# found has been responded by the server.
-#
-(project \
-  (restrict :combined, lambda{ http_status == 404 }),
-  [:path, :http_method, :http_version])

data/examples/logs/robots-cheating.alf

@@ -1,11 +0,0 @@
-#
-# Given that robots include (see robots.alf): 
-#   - those whose name matches /[Bb]ot/ 
-#   - those who request robots.txt
-#
-# Who are cheaters, that is, those who request robots.txt but are not
-# named /[Bb]ot/ ?
-# 
-(minus \
-  (project (restrict :combined, lambda{ path       =~ /robots.txt/ }), [:user_agent]),
-  (project (restrict :combined, lambda{ user_agent =~ /[Bb]ot/     }), [:user_agent]))

data/examples/logs/robots.alf

@@ -1,8 +0,0 @@
-#
-# Give the names of user agent that look like robots. This includes: 
-#   - those whose name matches /[Bb]ot/ 
-#   - those who request robots.txt
-# 
-(project \
-  (restrict :combined, lambda{ user_agent =~ /[Bb]ot/ or path =~ /robots.txt/ }), 
-  [:user_agent])

data/examples/operators/autonum.alf

@@ -1,6 +0,0 @@
-#!/usr/bin/env alf
-# Autonumber suppliers (:autonum attribute name by default)
-(autonum :suppliers)
-
-# You can specify the attribute name
-(autonum :suppliers, :unique_id)

data/examples/operators/cities.rash

@@ -1,4 +0,0 @@
-{:city => 'London',   :country => 'England'}
-{:city => 'Paris',    :country => 'France'}
-{:city => 'Athens',   :country => 'Greece'}
-{:city => 'Brussels', :country => 'Belgium'} 

data/examples/operators/clip.alf

@@ -1,3 +0,0 @@
-#!/usr/bin/env alf
-(clip :suppliers, [:name, :city])
-(clip :suppliers, [:name, :city], :allbut => true)

data/examples/operators/compact.alf

@@ -1,2 +0,0 @@
-#!/usr/bin/env alf
-(compact (clip :suppliers, [:city]))

data/examples/operators/database.alf

@@ -1,5 +0,0 @@
-Relation({
-  :suppliers => (Relation :suppliers),
-  :parts     => (Relation :parts),
-  :supplies  => (Relation :supplies),
-})

data/examples/operators/defaults.alf

@@ -1,3 +0,0 @@
-#!/usr/bin/env alf
-(defaults :suppliers, :country => 'Belgium')
-(defaults :suppliers, {:country => 'Belgium'}, :strict => true)

data/examples/operators/extend.alf

@@ -1,3 +0,0 @@
-#!/usr/bin/env alf
-(extend :supplies, :sp  => lambda{ sid + "/" + pid },
-                   :big => lambda{ qty > 100 ? true : false }) 

data/examples/operators/group.alf

@@ -1,3 +0,0 @@
-#!/usr/bin/env alf
-(group :supplies, [:pid, :qty], :supplying)
-(group :supplies, [:sid], :supplying, :allbut => true)

data/examples/operators/intersect.alf

@@ -1,4 +0,0 @@
-#!/usr/bin/env alf
-(intersect \
-  (restrict :suppliers, lambda{ status >= 20 }),
-  (restrict :suppliers, lambda{ city == 'Paris' }))

data/examples/operators/join.alf

@@ -1,2 +0,0 @@
-#!/usr/bin/env alf
-(join :suppliers, :supplies)

data/examples/operators/matching.alf

@@ -1,2 +0,0 @@
-#!/usr/bin/env alf
-(matching :suppliers, :supplies)

data/examples/operators/minus.alf

@@ -1,8 +0,0 @@
-#!/usr/bin/env alf
-# Give all suppliers, except those living in Paris
-(minus :suppliers, 
-       (restrict :suppliers, lambda{ city == 'Paris' }))
-
-# This is a contrived example for illustrating minus, as the
-# following is equivalent
-(restrict :suppliers, lambda{ city != 'Paris' })

data/examples/operators/not_matching.alf

@@ -1,2 +0,0 @@
-#!/usr/bin/env alf
-(not_matching :suppliers, :supplies)

data/examples/operators/nulls.rash

@@ -1,3 +0,0 @@
-{:sid => 'S1', :age => nil}
-{:sid => 'S2', :age => 32}
-{:sid => 'S3', :age => nil}

data/examples/operators/parts.rash

@@ -1,6 +0,0 @@
-{:pid => 'P1', :name => 'Nut',   :color => 'Red',   :weight => 12.0, :city => 'London'}
-{:pid => 'P2', :name => 'Bolt',  :color => 'Green', :weight => 17.0, :city => 'Paris'}
-{:pid => 'P3', :name => 'Screw', :color => 'Blue',  :weight => 17.0, :city => 'Oslo'}
-{:pid => 'P4', :name => 'Screw', :color => 'Red',   :weight => 14.0, :city => 'London'}
-{:pid => 'P5', :name => 'Cam',   :color => 'Blue',  :weight => 12.0, :city => 'Paris'}
-{:pid => 'P6', :name => 'Cog',   :color => 'Red',   :weight => 19.0, :city => 'London'}

data/examples/operators/project.alf

@@ -1,3 +0,0 @@
-#!/usr/bin/env alf
-(project :suppliers, [:name, :city])
-(project :suppliers, [:name, :city], :allbut => true)

data/examples/operators/pseudo-with.alf

@@ -1,7 +0,0 @@
-kept_suppliers = (restrict :suppliers, lambda{ status > 10 })
-with_countries = (join kept_suppliers, :cities)
-supplying      = (join with_countries, :supplies)
-(summarize supplying,
-           [:country],
-           :which => collect{ pid },
-           :total => sum{ qty })

data/examples/operators/quota.alf

@@ -1,4 +0,0 @@
-#!/usr/bin/env alf
-(quota :supplies, [:sid], [:qty],
-       :position => count(),
-       :sum_qty  => sum{ qty })

data/examples/operators/rank.alf

@@ -1,4 +0,0 @@
-#!/usr/bin/env alf
-
-# Get the three heaviest parts
-(allbut (restrict (rank :parts, [[:weight, :desc]], :pos), lambda{ pos < 3 }), [:pos])

data/examples/operators/rename.alf

@@ -1,3 +0,0 @@
-#!/usr/bin/env alf
-(rename :suppliers, :name => :supplier_name, 
-                    :city => :supplier_city)

data/examples/operators/restrict.alf

@@ -1,2 +0,0 @@
-#!/usr/bin/env alf
-(restrict :suppliers, lambda{ status > 20 })

data/examples/operators/schema.yaml

@@ -1,28 +0,0 @@
-logical: 
-  - name: suppliers
-    heading:
-      - { name: sid,    domain: String,   mandatory: true }
-      - { name: name,   domain: String,   mandatory: true }
-      - { name: status, domain: Integer,  mandatory: true }
-      - { name: city,   domain: String,   mandatory: true }
-    constraints: 
-      - { name: pk, type: primary_key, attributes: [ sid ] }
-  - name: parts
-    heading:
-      - { name: pid,    domain: String,   mandatory: true }
-      - { name: name,   domain: String,   mandatory: true }
-      - { name: color,  domain: String,   mandatory: true }
-      - { name: weight, domain: Float,    mandatory: true }
-      - { name: city,   domain: String,   mandatory: true }
-    constraints: 
-      - { name: pk, type: primary_key, attributes: [ pid ] }
-  - name: supplies
-    heading:
-      - { name: sid,    domain: String,   mandatory: true }
-      - { name: pid,    domain: String,   mandatory: true }
-      - { name: qty,    domain: Integer,  mandatory: true }
-    constraints: 
-      - { name: pk, type: primary_key, attributes: [ sid, pid ] }
-      - { name: known_supplier, type: foreign_key, attributes: [ sid ], references: suppliers }
-      - { name: known_part,     type: foreign_key, attributes: [ pid ], references: parts }
-      

data/examples/operators/sort.alf

@@ -1,4 +0,0 @@
-#!/usr/bin/env alf
-(sort :suppliers, [:name])
-(sort :suppliers, [:city, :name])
-(sort :suppliers, [[:city, :desc], [:name, :asc]])

data/examples/operators/summarize.alf

@@ -1,16 +0,0 @@
-#!/usr/bin/env alf
-
-# What is the sum of supplied quantities by supplier?
-(summarize :supplies, 
-           [:sid],
-           :total_qty => sum{ qty })
-
-# Give the maximal supplied quantity by country, taking only into account
-# suppliers that have a status greater than 10
-(summarize \
-  (join \
-    (join (restrict :suppliers, lambda{ status > 10 }), 
-          :supplies), 
-    :cities),
-  [:country], 
-  :maxqty => sum{ qty })

data/examples/operators/suppliers.rash

@@ -1,5 +0,0 @@
-{:sid => 'S1', :name => 'Smith', :status => 20, :city => 'London'}
-{:sid => 'S2', :name => 'Jones', :status => 10, :city => 'Paris'}
-{:sid => 'S3', :name => 'Blake', :status => 30, :city => 'Paris'}
-{:sid => 'S4', :name => 'Clark', :status => 20, :city => 'London'}
-{:sid => 'S5', :name => 'Adams', :status => 30, :city => 'Athens'}

data/examples/operators/supplies.rash

@@ -1,12 +0,0 @@
-{:sid => 'S1', :pid => 'P1', :qty => 300}
-{:sid => 'S1', :pid => 'P2', :qty => 200}
-{:sid => 'S1', :pid => 'P3', :qty => 400}
-{:sid => 'S1', :pid => 'P4', :qty => 200}
-{:sid => 'S1', :pid => 'P5', :qty => 100}
-{:sid => 'S1', :pid => 'P6', :qty => 100}
-{:sid => 'S2', :pid => 'P1', :qty => 300}
-{:sid => 'S2', :pid => 'P2', :qty => 400}
-{:sid => 'S3', :pid => 'P2', :qty => 200}
-{:sid => 'S4', :pid => 'P2', :qty => 200}
-{:sid => 'S4', :pid => 'P4', :qty => 300}
-{:sid => 'S4', :pid => 'P5', :qty => 400}

data/examples/operators/ungroup.alf

@@ -1,4 +0,0 @@
-#!/usr/bin/env alf
-(ungroup \
-  (group :supplies, [:pid, :qty], :supplying), 
-  :supplying)

data/examples/operators/union.alf

@@ -1,3 +0,0 @@
-#!/usr/bin/env alf
-(union (project :suppliers, [:city]), 
-       (project :parts,     [:city]))

data/examples/operators/unwrap.alf

@@ -1,4 +0,0 @@
-#!/usr/bin/env alf 
-(unwrap \
-  (wrap :suppliers, [:city, :status], :loc_and_status), 
-  :loc_and_status)

data/examples/operators/wrap.alf

@@ -1,2 +0,0 @@
-#!/usr/bin/env alf
-(wrap :suppliers, [:city, :status], :loc_and_status)

data/lib/alf-csv/alf/csv.rb

@@ -1,3 +0,0 @@
-require_relative 'csv/commons'
-require_relative 'csv/reader'
-require_relative 'csv/renderer'

data/lib/alf-csv/alf/csv/commons.rb

@@ -1,36 +0,0 @@
-module Alf
-  module CSV
-    #
-    # Provides common tooling to CSV renderer and readers
-    #
-    module Commons
-
-      DEFAULT_OPTIONS = {
-        :headers => true
-      }
-
-      private
-
-      # Returns CSV in ruby 1.9 and FasterCSV for ruby < 1.9.
-      # This method handles require as well.
-      def get_csv_class
-        if RUBY_VERSION >= "1.9"
-          require 'csv'
-          ::CSV
-        else
-          ::Alf::Tools::friendly_require('fastercsv')
-          ::FasterCSV
-        end
-      end
-
-      # Returns a CSV instance bound to a given io and options
-      def get_csv(io)
-        csv_class = get_csv_class
-        def_opts = csv_class.const_get(:DEFAULT_OPTIONS)
-        csv_opts = options.delete_if{|k,v| !def_opts.has_key?(k)}
-        csv_class.new(io, csv_opts)
-      end
-
-    end # module Commons
-  end # module CSV
-end # module Alf

data/lib/alf-csv/alf/csv/reader.rb

@@ -1,33 +0,0 @@
-module Alf
-  module CSV
-    #
-    # Implements Alf::Reader contract for reading CSV files.
-    #
-    class Reader < Alf::Reader
-      include CSV::Commons
-
-      def each
-        with_input_io do |io|
-          block = Proc.new{|row|
-            next if row.header_row?
-            yield(symbolize_keys(row.to_hash))
-          }
-          case io
-          when StringIO
-            get_csv_class.parse(io.string, options, &block) 
-          else
-            get_csv(io).each(&block)
-          end
-        end
-      end
-
-      private
-
-      def symbolize_keys(h)
-        Hash[h.collect{|k,v| [k.to_sym,v] }]
-      end
-
-      Alf::Reader.register(:csv, [".csv"], self)
-    end # class Reader
-  end # module CSV
-end # module Alf

data/lib/alf-csv/alf/csv/renderer.rb

@@ -1,38 +0,0 @@
-module Alf
-  module CSV
-    #
-    # Implements Alf::Renderer contract for outputting CSV files. 
-    #
-    class Renderer < Alf::Renderer
-      include CSV::Commons
-
-      protected
-
-      # (see Renderer#render)
-      def render(input, output)
-        csv = get_csv(output)
-        header = nil
-        input.each do |tuple|
-          unless header 
-            header = extract_header(tuple)
-            csv << header.collect{|k| k.to_s}
-          end
-          csv << extract_row(tuple, header)
-        end
-        output
-      end
-
-      private
-
-      def extract_header(tuple)
-        tuple.keys
-      end
-
-      def extract_row(tuple, header)
-        header.collect{|k| tuple[k]}
-      end
-
-      Alf::Renderer.register(:csv, "as a csv file", self)
-    end # class Renderer
-  end # module CSV
-end # module Alf

data/lib/alf-engine/alf/engine.rb

@@ -1,25 +0,0 @@
-require_relative 'engine/cog'
-require_relative 'engine/cesure'
-require_relative 'engine/autonum'
-require_relative 'engine/clip'
-require_relative 'engine/coerce'
-require_relative 'engine/generator'
-require_relative 'engine/compact'
-require_relative 'engine/defaults'
-require_relative 'engine/sort'
-require_relative 'engine/set_attr'
-require_relative 'engine/filter'
-require_relative 'engine/concat'
-require_relative 'engine/aggregate'
-require_relative 'engine/rename'
-require_relative 'engine/materialize'
-require_relative 'engine/group'
-require_relative 'engine/join'
-require_relative 'engine/semi'
-require_relative 'engine/wrap'
-require_relative 'engine/unwrap'
-require_relative 'engine/summarize'
-require_relative 'engine/rank'
-require_relative 'engine/quota'
-require_relative 'engine/ungroup'
-

data/lib/alf-engine/alf/engine/aggregate.rb

@@ -1,44 +0,0 @@
-module Alf
-  module Engine
-    #
-    # Aggregates the whole operand according to a Summarization. The resulting
-    # iterator contains only one tuple.
-    #
-    # Example:
-    #
-    #   res = [
-    #     {:name => "Jones", :price => 12.0, :id => 1},
-    #     {:name => "Smith", :price => 10.0, :id => 2}
-    #   ]
-    #   agg = Summarization[:size  => "count", 
-    #                       :total => "sum{ price }"]
-    #   Aggregate.new(res, agg).to_a
-    #   # => [
-    #   #      {:size => 2, :total => 22.0}
-    #   #    ]
-    #
-    class Aggregate < Cog
-
-      # @return [Enumerable] The operand
-      attr_reader :operand
-
-      # @return [Summarization] The summarization to use
-      attr_reader :summarization
-
-      # Creates an Aggregate instance
-      def initialize(operand, summarization)
-        @operand = operand
-        @summarization = summarization
-      end
-
-      # (see Cog#each)
-      def each
-        agg = operand.inject(@summarization.least) do |memo,tuple|
-          @summarization.happens(memo, tuple)
-        end
-        yield @summarization.finalize(agg)
-      end
-
-    end # class Aggregate
-  end # Engine
-end # module Alf