alf-core 0.13.0

data/lib/alf-relation/alf/tuple.rb

@@ -0,0 +1,103 @@
+module Alf
+  class Tuple
+    extend Domain::Reuse.new(Hash)
+    extend Domain::HeadingBased.new(self)
+
+    reuse :map, :size, :empty?, :[], :to_a, :keys, :values_at, :has_key?
+
+    coercions do |c|
+      c.coercion(Tuple){|tuple,type|
+        c.coerce(tuple.to_hash, type)
+      }
+      c.coercion(Hash){|hash,type|
+        type    = Tuple[Heading.infer(hash)] if Tuple==type
+        hash    = type.heading.coerce(hash)
+        type.new(hash).check_internal_representation!
+      }
+    end
+
+    def self.heading_based_factored
+      heading.each do |attrname,attrtype|
+        define_method(attrname) do |*args, &bl|
+          return super(*args, &bl) unless args.empty? && bl.nil?
+          reused_instance[attrname]
+        end
+      end
+      self
+    end
+
+    def check_internal_representation!
+      error = lambda{|msg| raise TypeError, msg }
+      error["Hash expected for representation"] unless reused_instance.is_a?(Hash)
+      TypeCheck.new(heading, true).check!(reused_instance)
+      self
+    rescue TypeCheck::Error => ex
+      error[ex.message]
+    end
+
+    def heading
+      self.class.heading
+    end
+
+    def split(attr_list)
+      return [ EMPTY, self ] if attr_list.empty?
+      left, right = {}, to_hash
+      (heading.to_attr_list & attr_list).each do |a|
+        left[a] = right.delete(a)
+      end
+      self.class.split(attr_list).zip([left, right]).map{|t,v| t.new(v) }
+    end
+
+    def project(attr_list)
+      split(attr_list).first
+    end
+
+    def allbut(attr_list)
+      split(attr_list).last
+    end
+
+    def rename(renaming)
+      renaming = Renaming.coerce(renaming)
+      self.class.rename(renaming).new(renaming.rename_tuple(reused_instance))
+    end
+
+    def extend(computation)
+      computation   = TupleComputation.coerce(computation)
+      scope         = Support::TupleScope.new(self)
+      computed      = computation.evaluate(scope)
+      res_heading   = heading.merge(Heading.infer(computed))
+      Tuple[res_heading].new(reused_instance.merge(computed))
+    end
+
+    def remap(&bl)
+      res = reused_instance.each_with_object({}){|(k,v),n| n[k] = bl[k, v]}
+      Tuple[Heading.infer(res)].new(res)
+    end
+
+    def merge(other)
+      res = reused_instance.merge(other.to_hash)
+      Tuple[Heading.infer(res)].new(res)
+    end
+
+    def to_hash(dup = true)
+      dup ? reused_instance.dup : reused_instance
+    end
+
+    def to_json(*args, &bl)
+      to_hash.to_json(*args, &bl)
+    end
+
+    def to_attr_list
+      heading.to_attr_list
+    end
+
+    def to_ruby_literal
+      "Tuple(#{Support.to_ruby_literal(to_hash)})"
+    end
+    alias_method :inspect, :to_ruby_literal
+    alias_method :to_s, :to_ruby_literal
+
+    EMPTY = Tuple[{}].new({})
+    DUM   = EMPTY
+  end # module Tuple
+end # module Alf

data/lib/alf-relvar/alf/relvar.rb

@@ -0,0 +1,87 @@
+module Alf
+  module Relvar
+    include Algebra::Operand
+    include Lang::ObjectOriented
+
+    def type
+      @type ||= Relation[heading]
+    end
+
+    def each(&bl)
+      to_cog.each(&bl)
+    end
+
+    def empty?
+      to_cog.each{|_| return false }
+      true
+    end
+
+    def empty!(msg = "relvar is empty")
+      raise FactAssertionError, msg unless empty?
+      self
+    end
+
+    def not_empty!(msg = "relvar is not empty")
+      raise FactAssertionError, msg if empty?
+      self
+    end
+
+    def value
+      to_relation
+    end
+
+    def lock(*)
+      raise NotSupportedError
+    end
+
+    def affect(value)
+      delete
+      insert(value)
+    end
+
+    def insert(tuples)
+      raise NotSupportedError
+    end
+
+    def delete(predicate = Predicate.tautology)
+      raise NotSupportedError
+    end
+
+    def update(updating, predicate = Predicate.tautology)
+      raise NotSupportedError
+    end
+
+    def upsert(tuples)
+      empty? ? insert(tuples) : update(tuples)
+    end
+
+    def safe(*args, &bl)
+      Safe.new(self, *args, &bl)
+    end
+
+    def to_relvar
+      self
+    end
+
+    def to_lispy
+      raise NotImplementedError
+    end
+
+    def to_relation
+      type.new(to_cog.to_set)
+    rescue NotSupportedError
+      Relation.coerce(to_cog.each.to_a)
+    end
+
+  private
+
+    def _operator_output(expr)
+      Relvar::Virtual.new(expr, connection)
+    end
+
+  end # module Relvar
+end # module Alf
+require_relative 'relvar/base'
+require_relative 'relvar/virtual'
+require_relative 'relvar/read_only'
+require_relative 'relvar/fake'

data/lib/alf-relvar/alf/relvar/base.rb

@@ -0,0 +1,64 @@
+module Alf
+  module Relvar
+    class Base
+      include Relvar
+
+      def initialize(name, connection = nil)
+        raise unless name.is_a?(Symbol)
+        @name = name
+        @connection = connection
+      end
+      attr_reader :name
+
+      ### Static analysis & inference
+
+      def heading
+        connection!.heading(name)
+      end
+
+      def keys
+        connection!.keys(name)
+      end
+
+      ### Update
+
+      def lock(mode = :exclusive, &bl)
+        connection!.lock(name, mode, &bl)
+      end
+
+      def insert(tuples)
+        tuples = [ tuples ] if TupleLike===tuples
+        connection!.insert(name, tuples)
+      end
+
+      def delete(predicate = Predicate.tautology)
+        connection!.delete(name, predicate)
+      end
+
+      def update(updating, predicate = Predicate.tautology)
+        connection!.update(name, updating, predicate)
+      end
+
+      ### to_xxx
+
+      def to_cog
+        connection!.cog(name)
+      end
+
+      def to_lispy
+        name.to_s
+      end
+
+      def to_s
+        "Relvar::Base(#{name.inspect})"
+      end
+
+    private
+
+      def _self_operand
+        self
+      end
+
+    end # class Base
+  end # module Relvar
+end # module Alf

data/lib/alf-relvar/alf/relvar/fake.rb

@@ -0,0 +1,34 @@
+module Alf
+  module Relvar
+    class Fake
+      include Relvar
+
+      def initialize(heading)
+        @heading = Heading.coerce(heading)
+      end
+      attr_reader :heading
+
+      def insert(tuples)
+        @inserted_tuples = tuples.to_a
+      end
+      attr_reader :inserted_tuples
+
+      def delete(predicate = Predicate.tautology)
+        @delete_predicate = predicate
+      end
+      attr_reader :delete_predicate
+
+      def update(updating, predicate = Predicate.tautology)
+        @updating = updating.to_hash
+        @update_predicate = predicate
+      end
+      attr_reader :updating
+      attr_reader :update_predicate
+
+      def to_lispy
+        "Relvar::Fake(#{heading.to_lispy})"
+      end
+
+    end # class Fake
+  end # module
+end # module Alf

data/lib/alf-relvar/alf/relvar/read_only.rb

@@ -0,0 +1,67 @@
+module Alf
+  module Relvar
+    class ReadOnly
+      include Relvar
+
+      def initialize(value)
+        @value = value
+      end
+      attr_reader :value
+
+      ### Static analysis & inference
+
+      def type
+        value.class
+      end
+
+      def heading
+        value.heading
+      end
+
+      def keys
+        value.keys
+      end
+
+      ### Update
+
+      def lock(mode = :exclusive)
+        yield
+      end
+
+      def insert(tuples)
+        raise ReadOnlyError, "Unable to insert in read-only relation variables"
+      end
+
+      def delete(predicate = Predicate.tautology)
+        raise ReadOnlyError, "Unable to delete in read-only relation variables"
+      end
+
+      def update(updating, predicate)
+        raise ReadOnlyError, "Unable to update read-only relation variables"
+      end
+
+      ### to_xxx
+
+      alias_method :to_relation, :value
+
+      def to_cog
+        value.to_cog
+      end
+
+      def to_lispy
+        value.to_lispy
+      end
+
+      def to_s
+        "Relvar::ReadOnly(#{value.to_s})"
+      end
+
+    private
+
+      def _self_operand
+        value
+      end
+
+    end # class Base
+  end # module Relvar
+end # module Alf

data/lib/alf-relvar/alf/relvar/virtual.rb

@@ -0,0 +1,62 @@
+module Alf
+  module Relvar
+    class Virtual
+      include Relvar
+
+      def initialize(expr, connection = nil)
+        @expr = expr
+        @connection = connection
+      end
+      attr_reader :expr
+
+      ### Static analysis & inference
+
+      def heading
+        expr.heading
+      end
+
+      def keys
+        expr.keys
+      end
+
+      ### Update
+
+      # Inserts some tuples inside this relation variable.
+      def insert(tuples)
+        tuples = [ tuples ] if TupleLike===tuples
+        Update::Inserter.new.call(expr, tuples)
+      end
+
+      # Updates all tuples of this relation variable.
+      def update(computation, predicate = Predicate.tautology)
+        Update::Updater.new.call(expr, computation, predicate)
+      end
+
+      # Delete all tuples of this relation variable.
+      def delete(predicate = Predicate.tautology)
+        Update::Deleter.new.call(expr, predicate)
+      end
+
+      ### to_xxx
+
+      def to_cog
+        connection!.cog(expr)
+      end
+
+      def to_lispy
+        expr.to_lispy
+      end
+
+      def to_s
+        "Relvar::Virtual(#{expr})"
+      end
+
+    private
+
+      def _self_operand
+        expr
+      end
+
+    end # class Base
+  end # module Relvar
+end # module Alf

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

@@ -0,0 +1,21 @@
+module Alf
+  #
+  # Provides tooling methods that are used here and there in Alf.
+  #
+  module Support
+
+    extend self
+  end # module Support
+  Tools = Support
+end # module Alf
+require_relative 'support/registry'
+require_relative 'support/coerce'
+require_relative 'support/to_ruby_literal'
+require_relative 'support/to_lispy'
+require_relative 'support/scope'
+require_relative 'support/tuple_scope'
+require_relative 'support/miscellaneous'
+require_relative 'support/bindable'
+require_relative 'support/ordered_set'
+require_relative 'support/config'
+require_relative 'support/dot_utils'

data/lib/alf-support/alf/support/bindable.rb

@@ -0,0 +1,26 @@
+module Alf
+  module Support
+    module Bindable
+
+      attr_accessor :connection
+      protected :connection=
+
+      def bind(connection)
+        dup.tap{|c|
+          c.connection = connection
+          yield(c) if block_given?
+        }
+      end
+
+      def bound?
+        defined?(@connection) && !@connection.nil?
+      end
+
+      def connection!
+        raise UnboundError unless bound?
+        @connection
+      end
+
+    end # module Bindable
+  end # module Support
+end # module Alf