alf-core 0.13.0

data/lib/alf-algebra/alf/algebra/support/unary.rb

@@ -0,0 +1,34 @@
+module Alf
+  module Algebra
+    #
+    # Specialization of Operator for operators that work on a unary input
+    #
+    module Unary
+
+      # Class-level methods
+      module ClassMethods
+
+        # (see Operator::ClassMethods#arity)
+        def arity
+          1
+        end
+
+      end # module ClassMethods
+
+      def self.included(mod)
+        super
+        mod.extend(ClassMethods)
+      end
+
+      # Simply returns the first operand
+      def operand
+        operands.first
+      end
+
+      def with_operand(operand)
+        with_operands(operand)
+      end
+
+    end # module Unary
+  end # module Algebra
+end # module Alf

data/lib/alf-algebra/alf/algebra/support/visitor.rb

@@ -0,0 +1,31 @@
+module Alf
+  module Algebra
+    module Visitor
+
+      def copy_and_apply(expr)
+        if expr.is_a?(Algebra::Operator)
+          expr.with_operands(*expr.operands.map{|op| apply(op) })
+        else
+          expr
+        end
+      end
+
+    private
+
+      def to_method_name(expr, prefix = "on_")
+        case expr
+        when Algebra::Operator
+          name = Support.ruby_case(Support.class_name(expr.class))
+          meth = :"#{prefix}#{name}"
+          meth = :"#{prefix}missing" unless respond_to?(meth)
+          meth
+        when Algebra::Operand
+          :on_leaf_operand
+        else
+          :not_supported
+        end
+      end
+
+    end # module Visitor
+  end # module Algebra
+end # module Alf

data/lib/alf-core.rb

@@ -0,0 +1,37 @@
+require_relative 'alf-core/loader'
+require_relative 'alf-core/version'
+require_relative 'alf-core/errors'
+require_relative 'alf-core/ext'
+require_relative 'alf-core/facade'
+
+module Alf
+  TupleLike    = lambda{|t| t.is_a?(Hash) || t.is_a?(Tuple) }
+  RelationLike = lambda{|r| Relation===r || Engine::Cog===r || Reader===r || Relvar===r }
+end
+
+require_relative 'alf-predicate/alf/predicate'
+require_relative 'alf-support/alf/support'
+require_relative 'alf-types/alf/types'
+require_relative 'alf-aggregator/alf/aggregator'
+require_relative 'alf-algebra/alf/algebra'
+require_relative "alf-engine/alf/engine"
+require_relative 'alf-io/alf/io'
+require_relative 'alf-lang/alf/lang'
+require_relative 'alf-relation/alf/relation'
+require_relative 'alf-relvar/alf/relvar'
+require_relative 'alf-optimizer/alf/optimizer'
+require_relative 'alf-update/alf/update'
+require_relative 'alf-adapter/alf/adapter'
+require_relative 'alf-viewpoint/alf/viewpoint'
+require_relative 'alf-database/alf/database'
+require_relative 'alf-adapter-fs/alf/adapter/fs'
+
+module Alf
+  extend Facade
+
+  DUM = Relation::DUM
+  DEE = Relation::DEE
+end
+
+require_relative 'alf-core/dsl'
+include Alf::Dsl unless defined?(ALF_NO_CORE_EXTENSIONS)

data/lib/alf-core/dsl.rb

@@ -0,0 +1,22 @@
+module Alf
+  module Dsl
+
+    Tuple    = Alf::Tuple
+    Relation = Alf::Relation
+    DUM      = Alf::Relation::DUM
+    DEE      = Alf::Relation::DEE
+
+    def Relation(*args, &bl)
+      Alf::Relation(*args, &bl)
+    end
+
+    def Tuple(*args, &bl)
+      Alf::Tuple(*args, &bl)
+    end
+
+    def Heading(*args, &bl)
+      Alf::Heading(*args, &bl)
+    end
+
+  end # module Dsl
+end # module Alf

data/lib/alf-core/errors.rb

@@ -0,0 +1,16 @@
+module Alf
+  class Error < StandardError; end
+  class ConfigError < Alf::Error; end
+  class UnboundError < StandardError; end
+  class NotSupportedError < Error; end
+  class NoSuchRelvarError < Error; end
+  class NoSuchTupleError < Error; end
+  class FactAssertionError < Error; end
+  class CoercionError < Error; end
+  class ReadOnlyError < Error; end
+  class TypeCheckError < Error; end
+  class IllegalStateError < Error; end
+
+  # deprecated
+  class UnsupportedError < Error; end
+end

data/lib/alf-core/ext.rb

@@ -0,0 +1 @@
+require_relative 'ext/domain/heading_based'

data/lib/alf-core/ext/domain/heading_based.rb

@@ -0,0 +1,88 @@
+module Domain
+  class HeadingBased < Module
+
+    def initialize(master_class)
+      define_method(:new){|*args|
+        raise "#{master_class}.new may not be called directly" if master_class==self
+        super(*args)
+      }
+      define_method(:type){|generating_type|
+        meths   = [
+          DomainMethods.new(master_class, generating_type),
+          AlgebraMethods.new(master_class, generating_type),
+          Domain::Comparisons,
+        ]
+        Class.new(master_class).extend(*meths).heading_based_factored
+      }
+      alias_method :[], :type
+      define_method(:heading_based_factored) do
+        self
+      end
+    end
+
+    class DomainMethods < Module
+
+      def initialize(master_class, gt)
+        define_method(:generating_type){
+          gt
+        }
+        define_method(:<=>){|other|
+          return nil unless other.ancestors.include?(master_class)
+          return -1 if other == master_class
+          to_heading <=> other.to_heading
+        }
+        define_method(:===){|value|
+          super(value) || (value.is_a?(master_class) && self >= value.class)
+        }
+        define_method(:hash){
+          @hash ||= 37*master_class.hash + generating_type.hash
+        }
+        define_method(:==){|other|
+          other.is_a?(Class) &&
+          other.superclass==master_class &&
+          other.to_heading==to_heading
+        }
+        define_method(:coerce){|arg|
+          master_class.coercions.apply(arg, self)
+        }
+        define_method(:to_heading){
+          @heading ||= Alf::Heading.coerce(generating_type)
+        }
+        define_method(:to_ruby_literal){
+          "#{master_class.name}[#{Alf::Support.to_ruby_literal(to_heading.to_hash)}]"
+        }
+        alias_method :name, :to_ruby_literal
+        alias_method :to_s, :to_ruby_literal
+        alias_method :inspect, :to_ruby_literal
+      end
+    end # module DomainMethods
+
+    class AlgebraMethods < Module
+
+      def initialize(master_class, generating_type)
+        define_method(:heading){
+          @heading ||= Alf::Heading.coerce(generating_type)
+        }
+        define_method(:split){|attr_list|
+          if attr_list.empty?
+            [ master_class::DUM.class, self ]
+          elsif attr_list==heading.to_attr_list
+            [ self, master_class::DUM.class ]
+          else
+            heading.split(attr_list).map{|h| master_class[h]}
+          end
+        }
+        define_method(:project){|attr_list|
+          split(attr_list).first
+        }
+        define_method(:allbut){|attr_list|
+          split(attr_list).last
+        }
+        define_method(:rename){|renaming|
+          master_class[heading.rename(renaming)]
+        }
+      end
+    end
+
+  end # module HeadingBased
+end # module Domain

data/lib/alf-core/facade.rb

@@ -0,0 +1,35 @@
+module Alf
+  module Facade
+
+    def database(*args, &bl)
+      Alf::Database.new(*args, &bl)
+    end
+
+    def connect(*args, &bl)
+      Alf::Database.connect(*args, &bl)
+    end
+
+    def examples(&bl)
+      Alf::Database.connect Path.backfind('examples/suppliers_and_parts'), &bl
+    end
+
+    def reader(source, *args)
+      Alf::Reader.reader(source, *args)
+    end
+
+    def Relation(*args, &bl)
+      Alf::Relation.coerce(*args, &bl)
+    end
+
+    def Tuple(*args, &bl)
+      tuple = Alf::Tuple.coerce(*args)
+      tuple = tuple.remap(&bl) if bl
+      tuple
+    end
+
+    def Heading(*args, &bl)
+      Alf::Heading.coerce(*args, &bl)
+    end
+
+  end
+end

data/lib/alf-core/loader.rb

@@ -0,0 +1,13 @@
+# Standard library
+require "enumerator"
+require "stringio"
+require "set"
+require "forwardable"
+require 'time'
+
+# Third party gems
+require "path"
+require "sexpr"
+require "myrrha"
+require 'myrrha/to_ruby_literal'
+require 'myrrha/coerce'

data/lib/alf-core/version.rb

@@ -0,0 +1,16 @@
+module Alf
+  module Core
+    module Version
+
+      MAJOR = 0
+      MINOR = 13
+      TINY  = 0
+
+      def self.to_s
+        [ MAJOR, MINOR, TINY ].join('.')
+      end
+
+    end
+    VERSION = Version.to_s
+  end
+end

data/lib/alf-database/alf/database.rb

@@ -0,0 +1,46 @@
+require_relative 'database/options'
+require_relative 'database/connection'
+module Alf
+  class Database
+    include Options.helpers(:default_options)
+
+    def self.new(conn_spec, options = {})
+      adapter = Adapter.factor(conn_spec)
+      options = Options.new(options)
+      yield(options) if block_given?
+      super(adapter, options)
+    end
+
+    def self.connect(conn_spec, options = {}, &bl)
+      db = new(conn_spec, options)
+      bl ? db.connect(&bl) : db.connection
+    end
+
+    def initialize(adapter, options)
+      @adapter = adapter
+      @default_options = options.freeze
+      @schema_cache = Adapter::Connection::SchemaCached.empty_cache
+    end
+    attr_reader :adapter, :default_options
+
+    ### connection handling
+
+    def connection(opts = {})
+      Connection.new(self, default_options.merge(opts)) do |conn_opts|
+        conn = adapter.connection
+        if conn_opts.schema_cache?
+          conn = Adapter::Connection::SchemaCached.new(conn, @schema_cache)
+        end
+        conn
+      end
+    end
+
+    def connect(opts = {})
+      c = connection(opts)
+      yield(c)
+    ensure
+      c.close if c
+    end
+
+  end # class Database
+end # module Alf

data/lib/alf-database/alf/database/connection.rb

@@ -0,0 +1,156 @@
+module Alf
+  class Database
+    class Connection
+      include Options.helpers(:options)
+      extend Forwardable
+
+      def initialize(db, options = Options.new, &connection_handler)
+        @db = db
+        @options = options.freeze
+        @connection_handler = connection_handler
+        open!
+      end
+      attr_reader :db, :options, :connection_handler
+
+      ### connection handling
+      private :connection_handler
+
+      def adapter_connection
+        @adapter_connection ||= connection_handler.call(options)
+      end
+      alias_method :open!, :adapter_connection
+      private :open!
+
+      def reconnect(opts = {})
+        close unless (opts.keys & [:schema_cache]).empty?
+        @options = options.merge(opts)
+        open!
+      end
+
+      def closed?
+        @adapter_connection.nil?
+      end
+
+      def close
+        adapter_connection.close unless closed?
+        @adapter_connection = nil
+      end
+
+      ### logical level
+
+      def parse(*args, &bl)
+        parser.parse(*args, &bl)
+      end
+
+      def optimize(*args, &bl)
+        optimizer.call(parse(*args, &bl))
+      end
+
+      def relvar(*args, &bl)
+        parse(*args, &bl).to_relvar
+      end
+
+      def query(*args, &bl)
+        relvar(*args, &bl).to_relation
+      end
+
+      def tuple_extract(*args, &bl)
+        relvar(*args, &bl).tuple_extract
+      end
+
+      def assert!(msg = "an assert! assertion failed", &bl)
+        relvar(&bl).not_empty!(msg)
+      end
+
+      def deny!(msg = "a deny! assertion failed", &bl)
+        relvar(&bl).empty!(msg)
+      end
+
+      def fact!(msg = "a fact! assertion failed", &bl)
+        relvar(&bl).tuple_extract
+      rescue NoSuchTupleError
+        raise FactAssertionError, msg
+      end
+
+      ### middleware level
+
+      def cog(expr, *args, &bl)
+        case expr
+        when Symbol           then adapter_connection.cog(*args.unshift(expr), &bl)
+        when Algebra::Operand then compile(expr)
+        else
+          raise ArgumentError, "Unable to compile `#{expr}` to a cog"
+        end
+      end
+
+      def lock(expr, mode = :exclusive, &bl)
+        case expr
+        when Symbol then adapter_connection.lock(expr, mode, &bl)
+        else
+          raise NotImplementedError, "Unable to lock virtual relvars"
+        end
+      end
+
+      ### physical level
+
+      def_delegators :adapter_connection, :in_transaction,
+                                          :knows?,
+                                          :heading,
+                                          :keys,
+                                          :insert,
+                                          :delete,
+                                          :update
+
+      def migrate!
+        adapter_connection.migrate!(options)
+      end
+
+      ### others
+
+      def to_s
+        "Alf::Database::Connection(#{adapter_connection})"
+      end
+
+    private
+
+      def compile(expr)
+        if df = options.debug_folder
+          where, i = options.debug_naming.call(expr), 1
+          debug_dot(expr, df/"#{where}/#{i}-Algebra.dot")
+          compilation_chain.inject(expr){|e,c|
+            c.call(e).tap{|mid|
+              name = "#{i}-#{Alf::Support.class_name(c.class)}"
+              debug_dot(mid, df/"#{where}/#{name}.dot")
+              i += 1
+            }
+          }
+        else
+          compilation_chain.inject(expr){|e,c| c.call(e) }
+        end
+      end
+
+      def optimizer
+        Optimizer.new.register(Optimizer::Restrict.new, Algebra::Restrict)
+      end
+
+      def compilation_chain
+        [ optimizer, adapter_connection.compiler ]
+      end
+
+      def parser
+        options.viewpoint.parser(self)
+      end
+
+      def debug_dot(e, where)
+        where.parent.mkdir_p
+        where.open('w') do |io|
+          e.to_dot(io)
+        end
+      rescue => ex
+        $stderr.puts ex.message
+        $stderr.puts ex.backtrace.join("\n")
+      end
+
+    end # class Connection
+  end # class Database
+end # module Alf