veritas 0.0.1

data/lib/veritas/algebra/restriction.rb

@@ -0,0 +1,96 @@
+module Veritas
+  module Algebra
+
+    # Restrict the tuples to those that match a predicate
+    class Restriction < Relation
+      include Relation::Operation::Unary
+
+      # The predicate for the relation
+      #
+      # @return [Expression, #call]
+      #
+      # @api private
+      attr_reader :predicate
+
+      # Initialize a Restriction
+      #
+      # @param [Relation] operand
+      #   the relation to restrict
+      # @param [Expression, #call] predicate
+      #   the expression to restrict the tuples with
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def initialize(operand, predicate)
+        super(operand)
+        @predicate = predicate
+      end
+
+      # Iterate over each tuple in the set
+      #
+      # @example
+      #   restriction = Restriction.new(operand, predicate)
+      #   restriction.each { |tuple| ... }
+      #
+      # @yield [tuple]
+      #
+      # @yieldparam [Tuple] tuple
+      #   each tuple in the set
+      #
+      # @return [self]
+      #
+      # @api public
+      def each
+        operand.each { |tuple| yield(tuple) if predicate.call(tuple) }
+        self
+      end
+
+      # Compare the Restriction with other relation for equality
+      #
+      # @example
+      #   restriction.eql?(other)  # => true or false
+      #
+      # @param [Relation] other
+      #   the other relation to compare with
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def eql?(other)
+        super && predicate.eql?(other.predicate)
+      end
+
+      module Methods
+
+        # Return a relation with restricted tuples
+        #
+        # @example restriction using a predicate
+        #   restriction = relation.restrict(relation.name.eq('other'))
+        #
+        # @example restriction using a block
+        #   restriction = relation.restrict { |r| r[:a].eq('other').and(r[:b].gte(42)) }
+        #
+        # @param [Expression, #call] predicate
+        #   optional predicate to restrict the tuples with
+        #
+        # @yield [relation]
+        #   optional block to restrict the tuples with
+        #
+        # @yieldparam [Relation] relation
+        #   the context to evaluate the restriction with
+        #
+        # @return [Restriction]
+        #
+        # @api public
+        def restrict(predicate = yield(self))
+          Restriction.new(self, predicate)
+        end
+
+      end # module Methods
+
+      Relation.class_eval { include Methods }
+
+    end # class Restriction
+  end # module Algebra
+end # module Veritas

data/lib/veritas/algebra/summarization.rb

@@ -0,0 +1,166 @@
+module Veritas
+  module Algebra
+
+    # Summarize a relation by specific attributes
+    class Summarization < Relation
+      include Relation::Operation::Unary
+
+      # The relation to summarize by
+      #
+      # @return [Relation]
+      #
+      # @api private
+      attr_reader :summarize_by
+
+      # The summarizers for the relation
+      #
+      # @return [Hash]
+      #
+      # @api private
+      attr_reader :summarizers
+
+      # Initialize a Summarization
+      #
+      # @param [Relation] operand
+      #   the relation to summarize
+      # @param [Relation] summarize_by
+      #   the relation to summarize by
+      # @param [#to_hash] summarizers
+      #   the summarizers to add
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def initialize(operand, summarize_by, summarizers)
+        super(operand)
+        @summarize_by = summarize_by
+        @summarizers  = summarizers.to_hash
+        @header       = @summarize_by.header | @summarizers.keys
+      end
+
+      # Iterate over each tuple in the set
+      #
+      # @example
+      #   summarization = Summarization.new(self, relation, evaluator.expressions)
+      #   summarization.each { |tuple| ... }
+      #
+      # @yield [tuple]
+      #
+      # @yieldparam [Tuple] tuple
+      #   each tuple in the set
+      #
+      # @return [self]
+      #
+      # @api public
+      def each
+        header      = self.header
+        summaries   = summarize_relation
+        summarizers = self.summarizers.values
+
+        summarize_by.each do |tuple|
+          yield tuple.join(header, summaries[tuple].values_at(*summarizers))
+        end
+
+        self
+      end
+
+    private
+
+      # Return the summaries for each tuple, grouped by the summarize_by header
+      #
+      # @return [Hash]
+      #
+      # @api private
+      def summarize_relation
+        header    = summarize_by.header
+        summaries = {}
+
+        operand.each do |tuple|
+          summarize_tuple(tuple, summaries[tuple.project(header)] ||= {})
+        end
+
+        summaries
+      end
+
+      # Calculate the summary for each function and tuple
+      #
+      # @param [Tuple] tuple
+      #   a tuple from the base relation
+      # @param [Hash] summary
+      #   the summary for a group of matching tuples
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def summarize_tuple(tuple, summary)
+        summarizers.each_value do |summarizer|
+          self.class.summarize(tuple, summary, summarizer)
+        end
+      end
+
+      # Calculate the summary for a function and tuple
+      #
+      # @param [Tuple] tuple
+      #   a tuple from the base relation
+      # @param [Hash] summary
+      #   the summary for a group of matching tuples
+      # @param [#call] summarizer
+      #   the function to call with the summary and tuple
+      #
+      # @return [self]
+      #
+      # @api private
+      def self.summarize(tuple, summary, summarizer)
+        summary[summarizer] = summarizer.call(summary[summarizer], tuple)
+        self
+      end
+
+      module Methods
+
+        # Return a summarized relation
+        #
+        # @example
+        #   summarization = relation.summarize(relation.project([ :name ])) do |expression|
+        #     expression.add(:count, expression[:name].count)
+        #   end
+        #
+        # @yield [expression]
+        #   Evaluate an summarization expression
+        #
+        # @yieldparam [Evaluator::Expression] expression
+        #   the context to evaluate the summarization with
+        #
+        # @return [Summarization]
+        #
+        # @api public
+        def summarize(summarize_by, &block)
+          relation  = coerce_to_relation(summarize_by)
+          evaluator = Evaluator::Expression.new(&block)
+          Summarization.new(self, relation, evaluator.expressions)
+        end
+
+      private
+
+        # Coerce the argument into a Relation
+        #
+        # @param [Relation, Header, #to_ary] summarize_by
+        #   the relation, header or attributes to summarize by
+        #
+        # @return [Relation]
+        #
+        # @api private
+        def coerce_to_relation(summarize_by)
+          if summarize_by.kind_of?(Relation)
+            summarize_by
+          else
+            project(Relation::Header.coerce(summarize_by))
+          end
+        end
+
+      end # module Methods
+
+      Relation.class_eval { include Methods }
+
+    end # class Summarization
+  end # module Algebra
+end # module Veritas

data/lib/veritas/algebra/union.rb

@@ -0,0 +1,54 @@
+module Veritas
+  module Algebra
+
+    # The union between relations
+    class Union < Relation
+      include Relation::Operation::Set
+
+      # Iterate over each tuple in the set
+      #
+      # @example
+      #   union = Union.new(left, right)
+      #   union.each { |tuple| ... }
+      #
+      # @yield [tuple]
+      #
+      # @yieldparam [Tuple] tuple
+      #   each tuple in the set
+      #
+      # @return [self]
+      #
+      # @api public
+      def each
+        seen = {}
+        left.each  { |tuple| yield(seen[tuple] = tuple)           }
+        right.each { |tuple| yield(tuple) unless seen.key?(tuple) }
+        self
+      end
+
+      module Methods
+        extend Aliasable
+
+        inheritable_alias(:| => :union)
+
+        # Return the union between relations
+        #
+        # @example
+        #   union = relation.union(other)
+        #
+        # @param [Relation] other
+        #
+        # @return [Union]
+        #
+        # @api public
+        def union(other)
+          Union.new(self, other)
+        end
+
+      end # module Methods
+
+      Relation.class_eval { include Methods }
+
+    end # class Union
+  end # module Algebra
+end # module Veritas

data/lib/veritas/algebra.rb

@@ -0,0 +1,10 @@
+require 'veritas/algebra/difference'
+require 'veritas/algebra/extension'
+require 'veritas/algebra/intersection'
+require 'veritas/algebra/join'
+require 'veritas/algebra/product'
+require 'veritas/algebra/projection'
+require 'veritas/algebra/rename'
+require 'veritas/algebra/restriction'
+require 'veritas/algebra/summarization'
+require 'veritas/algebra/union'

data/lib/veritas/attribute/boolean.rb

@@ -0,0 +1,39 @@
+module Veritas
+  class Attribute
+
+    # Represents a Boolean value in a relation tuple
+    class Boolean < Object
+      include Logic::Connective::Conjunction::Methods,
+              Logic::Connective::Disjunction::Methods,
+              Logic::Connective::Negation::Methods
+
+      # The Boolean primitive
+      #
+      # @example
+      #   Boolean.primitive  # => TrueClass
+      #
+      # @return [Class<TrueClass>]
+      #
+      # @api public
+      def self.primitive
+        TrueClass
+      end
+
+      # Test if the value is a boolean
+      #
+      # @example
+      #   boolean.valid_value?(value)  # => true or false
+      #
+      # @param [Object] value
+      #   the value to test
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def valid_value?(value)
+        valid_or_optional?(value) { super || value.kind_of?(FalseClass) }
+      end
+
+    end # class Boolean
+  end # class Attribute
+end # module Veritas

data/lib/veritas/attribute/class.rb

@@ -0,0 +1,21 @@
+module Veritas
+  class Attribute
+
+    # Represents a Class value in a relation tuple
+    class Class < Object
+
+      # The Class primitive
+      #
+      # @example
+      #   Class.primitive  # => ::Class
+      #
+      # @return [Class<::Class>]
+      #
+      # @api public
+      def self.primitive
+        ::Class
+      end
+
+    end # class Class
+  end # class Attribute
+end # module Veritas

data/lib/veritas/attribute/comparable.rb

@@ -0,0 +1,32 @@
+module Veritas
+  class Attribute
+
+    # A mixin for attributes that have comparable values
+    module Comparable
+      include Orderable,
+              Logic::Predicate::GreaterThan::Methods,
+              Logic::Predicate::GreaterThanOrEqualTo::Methods,
+              Logic::Predicate::LessThan::Methods,
+              Logic::Predicate::LessThanOrEqualTo::Methods
+
+
+      # Compare the attribute with other attribute to see if they are of the same type
+      #
+      # @example
+      #   attribute.comparable?(other)  # => true or false
+      #
+      # @param [Attribute] other
+      #   the other attribute to compare with
+      #
+      # @return [Boolean]
+      #
+      # @todo figure out how to dry this up with Attribute#joinable?
+      #
+      # @api public
+      def comparable?(other)
+        kind_of?(other.class) || other.kind_of?(self.class)
+      end
+
+    end # module Comparable
+  end # class Attribute
+end # module Veritas

data/lib/veritas/attribute/date.rb

@@ -0,0 +1,36 @@
+module Veritas
+  class Attribute
+
+    # Represents a Date value in a relation tuple
+    class Date < Object
+      include Comparable
+
+      DEFAULT_RANGE = (::Date.new..::Date::Infinity.new).freeze
+
+      # The Date primitive
+      #
+      # @example
+      #   Date.primitive  # => ::Date
+      #
+      # @return [Class<::Date>]
+      #
+      # @api public
+      def self.primitive
+        ::Date
+      end
+
+      # The Date range for a valid value
+      #
+      # @example
+      #   Date.range  # => ::Date.new(*from)..::Date.new(*to)
+      #
+      # @return [Range<::Date>]
+      #
+      # @api public
+      def range
+        DEFAULT_RANGE
+      end
+
+    end # class Date
+  end # class Attribute
+end # module Veritas

data/lib/veritas/attribute/date_time.rb

@@ -0,0 +1,36 @@
+module Veritas
+  class Attribute
+
+    # Represents a DateTime value in a relation tuple
+    class DateTime < Object
+      include Comparable
+
+      DEFAULT_RANGE = (::DateTime.new..::DateTime::Infinity.new).freeze
+
+      # The DateTime primitive
+      #
+      # @example
+      #   DateTime.primitive  # => ::DateTime
+      #
+      # @return [Class<::DateTime>]
+      #
+      # @api public
+      def self.primitive
+        ::DateTime
+      end
+
+      # The DateTime range for a valid value
+      #
+      # @example
+      #   DateTime.range  # => ::DateTime.new(*from)..::DateTime.new(*to)
+      #
+      # @return [Range<::DateTime>]
+      #
+      # @api public
+      def range
+        DEFAULT_RANGE
+      end
+
+    end # class DateTime
+  end # class Attribute
+end # module Veritas

data/lib/veritas/attribute/decimal.rb

@@ -0,0 +1,21 @@
+module Veritas
+  class Attribute
+
+    # Represents a Decimal value in a relation tuple
+    class Decimal < Numeric
+
+      # The Decimal primitive
+      #
+      # @example
+      #   Decimal.primitive  # => BigDecimal
+      #
+      # @return [Class<BigDecimal>]
+      #
+      # @api public
+      def self.primitive
+        BigDecimal
+      end
+
+    end # class Decimal
+  end # class Attribute
+end # module Veritas

data/lib/veritas/attribute/float.rb

@@ -0,0 +1,21 @@
+module Veritas
+  class Attribute
+
+    # Represents a Float value in a relation tuple
+    class Float < Numeric
+
+      # The Float primitive
+      #
+      # @example
+      #   Float.primitive  # => ::Float
+      #
+      # @return [Class<::Float>]
+      #
+      # @api public
+      def self.primitive
+        ::Float
+      end
+
+    end # class Float
+  end # class Attribute
+end # module Veritas

data/lib/veritas/attribute/integer.rb

@@ -0,0 +1,21 @@
+module Veritas
+  class Attribute
+
+    # Represents an Integer value in a relation tuple
+    class Integer < Numeric
+
+      # The Integer primitive
+      #
+      # @example
+      #   Integer.primitive  # => ::Integer
+      #
+      # @return [Class<::Integer>]
+      #
+      # @api public
+      def self.primitive
+        ::Integer
+      end
+
+    end # class Integer
+  end # class Attribute
+end # module Veritas

data/lib/veritas/attribute/numeric.rb

@@ -0,0 +1,86 @@
+module Veritas
+  class Attribute
+
+    # Represents a Numeric value in a relation tuple
+    class Numeric < Object
+      extend Aliasable
+      include Comparable
+
+      DEFAULT_SIZE = (0..2**31-1).freeze
+
+      inheritable_alias(:range => :size)
+
+      # The Numeric range for a valid value
+      #
+      # @example
+      #   numeric.size  # => 0..10
+      #
+      # @return [Range<::Numeric>]
+      #
+      # @api public
+      attr_reader :size
+
+      # The Numeric primitive
+      #
+      # @example
+      #   Numeric.primitive  # => ::Numeric
+      #
+      # @return [Class<::Numeric>]
+      #
+      # @api public
+      def self.primitive
+        ::Numeric
+      end
+
+      # Initialize a Numeric Attribute
+      #
+      # @param [#to_sym] name
+      #   the attribute name
+      # @param [#to_hash] options
+      #   the options for the attribute
+      # @option options [Boolean] :required (true)
+      #   if true, then the value cannot be nil
+      # @option options [Range<::Numeric>] :size (0..2**31-1)
+      #   The numeric range for a valid value
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def initialize(*)
+        super
+        @size = @options.fetch(:size, DEFAULT_SIZE).to_inclusive
+      end
+
+      # Test if the value matches the attribute constraints
+      #
+      # @example
+      #   numeric.valid_value?(value)  # => true or false
+      #
+      # @param [Object] value
+      #   the value to test
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def valid_value?(value)
+        valid_or_optional?(value) { super && size.include?(value) }
+      end
+
+      # Test if the attribute can be joined with the other attribute
+      #
+      # @example
+      #   numeric.joinable?(other)  # => true or false
+      #
+      # @param [Attribute] other
+      #   the other attribute to test
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def joinable?(other)
+        super && size.eql?(other.size)
+      end
+
+    end # class Numeric
+  end # class Attribute
+end # module Veritas

data/lib/veritas/attribute/object.rb

@@ -0,0 +1,25 @@
+module Veritas
+  class Attribute
+
+    # Represents an Object value in a relation tuple
+    class Object < Attribute
+      include Logic::Predicate::Equality::Methods,
+              Logic::Predicate::Exclusion::Methods,
+              Logic::Predicate::Inequality::Methods,
+              Logic::Predicate::Inclusion::Methods
+
+      # The Object primitive
+      #
+      # @example
+      #   Object.primitive  # => ::Object
+      #
+      # @return [Class<::Object>]
+      #
+      # @api public
+      def self.primitive
+        ::Object
+      end
+
+    end # class Object
+  end # class Attribute
+end # module Veritas

data/lib/veritas/attribute/orderable.rb

@@ -0,0 +1,33 @@
+module Veritas
+  class Attribute
+
+    # A mixin for attributes that have orderable values
+    module Orderable
+
+      # Sort the attribute in ascending order
+      #
+      # @example
+      #   ascending = attribute.asc
+      #
+      # @return [Relation::Operation::Order::Ascending]
+      #
+      # @api public
+      def asc
+        Relation::Operation::Order::Ascending.new(self)
+      end
+
+      # Sort the attribute in descending order
+      #
+      # @example
+      #   descending = attribute.desc
+      #
+      # @return [Relation::Operation::Order::Descending]
+      #
+      # @api public
+      def desc
+        Relation::Operation::Order::Descending.new(self)
+      end
+
+    end # module Orderable
+  end #class Attribute
+end # module Veritas