axiom 0.1.0

data/lib/axiom/function/proposition.rb

@@ -0,0 +1,97 @@
+# encoding: utf-8
+
+module Axiom
+  class Function
+
+    # Abstract base class for logical propositions
+    class Proposition < Function
+      include AbstractType,
+              Singleton,
+              Function::Connective::Conjunction::Methods,
+              Function::Connective::Disjunction::Methods,
+              Function::Connective::Negation::Methods
+      include Equalizer.new
+
+      # Instantiate a new Proposition
+      #
+      # @example using a true value
+      #   tautology = Proposition.new(true)
+      #
+      # @example using a false value
+      #   contradiction = Proposition.new(false)
+      #
+      # @return [Proposition]
+      #
+      # @overload self.new(true)
+      #   Return the Tautology singleton instance
+      #
+      #   @param [Array(true)] args
+      #
+      #   @return [Tautology]
+      #
+      # @overload self.new(false)
+      #   Return the Contradiction singleton instance
+      #
+      #   @param [Array(false)] args
+      #
+      #   @return [Contradiction]
+      #
+      # @api public
+      def self.new(*args)
+        if args.empty?
+          super
+        else
+          (args.first.equal?(true) ? Tautology : Contradiction).instance
+        end
+      end
+
+      # Evaluate the proposition
+      #
+      # @example
+      #   proposition.call  # => true or false
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def call(*)
+        self.class.call
+      end
+
+      # A no-op when receiving #rename message
+      #
+      # @example
+      #   proposition = proposition.rename(aliases)
+      #
+      # @param [Algebra::Rename::Aliases] _aliases
+      #
+      # @return [self]
+      #
+      # @api public
+      def rename(_aliases)
+        self
+      end
+
+      # Return the inverse proposition
+      #
+      # @example
+      #   inverse = proposition.inverse
+      #
+      # @return [Proposition]
+      #
+      # @api public
+      def inverse
+        self.class.inverse.instance
+      end
+
+      # Return the type returned from #call
+      #
+      # @return [Class<Attribute::Boolean>]
+      #
+      # @api public
+      def type
+        Attribute::Boolean
+      end
+
+    end # class Proposition
+  end # module Algebra
+end # module Axiom

data/lib/axiom/function/proposition/contradiction.rb

@@ -0,0 +1,66 @@
+# encoding: utf-8
+
+module Axiom
+  class Function
+    class Proposition
+
+      # A class representing a contradiction
+      class Contradiction < Proposition
+        include Connective::Negation::Methods
+
+        # Return the inverse proposition class
+        #
+        # @example
+        #   Contradiction.inverse  # => Tautology
+        #
+        # @return [Class<Tautology>]
+        #
+        # @api public
+        def self.inverse
+          Tautology
+        end
+
+        # Evaluate the proposition
+        #
+        # @example
+        #   Contradiction.call  # => false
+        #
+        # @return [false]
+        #
+        # @api public
+        def self.call
+          false
+        end
+
+        # Logically AND the proposition with another expression
+        #
+        # @example
+        #   contradiction.and(other)  # => contradiction
+        #
+        # @param [Function] _other
+        #
+        # @return [self]
+        #
+        # @api public
+        def and(_other)
+          self
+        end
+
+        # Logically OR the proposition with another expression
+        #
+        # @example
+        #   contradiction.or(other)  # => other
+        #
+        # @param [Function] other
+        #
+        # @return [Function]
+        #
+        # @api public
+        def or(other)
+          other
+        end
+
+      end # class Contradiction
+    end # class Proposition
+  end # module Algebra
+end # module Axiom

data/lib/axiom/function/proposition/tautology.rb

@@ -0,0 +1,66 @@
+# encoding: utf-8
+
+module Axiom
+  class Function
+    class Proposition
+
+      # A class representing a tautology
+      class Tautology < Proposition
+        include Connective::Negation::Methods
+
+        # Return the inverse proposition class
+        #
+        # @example
+        #   Tautology.inverse  # => Contradiction
+        #
+        # @return [Class<Contradiction>]
+        #
+        # @api public
+        def self.inverse
+          Contradiction
+        end
+
+        # Evaluate the proposition
+        #
+        # @example
+        #   Tautology.call  # => true
+        #
+        # @return [true]
+        #
+        # @api public
+        def self.call
+          true
+        end
+
+        # Logically AND the proposition with another expression
+        #
+        # @example
+        #   tautology.and(other)  # => other
+        #
+        # @param [Function] other
+        #
+        # @return [Function]
+        #
+        # @api public
+        def and(other)
+          other
+        end
+
+        # Logically OR the proposition with another expression
+        #
+        # @example
+        #   tautology.or(other)  # => tautology
+        #
+        # @param [Function] _other
+        #
+        # @return [self]
+        #
+        # @api public
+        def or(_other)
+          self
+        end
+
+      end # class Tautology
+    end # class Proposition
+  end # module Algebra
+end # module Axiom

data/lib/axiom/function/string/length.rb

@@ -0,0 +1,55 @@
+# encoding: utf-8
+
+module Axiom
+  class Function
+    module String
+
+      # A class representing a length function
+      class Length < Function
+        include Unary
+
+        # Return the string length
+        #
+        # @example
+        #   length = Length.call(value)
+        #
+        # @param [String] value
+        #
+        # @return [Integer]
+        #
+        # @api public
+        def self.call(value)
+          value.length
+        end
+
+        # Return the type returned from #call
+        #
+        # @return [Class<Attribute::Integer>]
+        #
+        # @api public
+        def type
+          Attribute::Integer
+        end
+
+        module Methods
+
+          # Return a length function
+          #
+          # @example
+          #   length = attribute.length
+          #
+          # @return [Length]
+          #
+          # @api public
+          def length
+            Length.new(self)
+          end
+
+        end # module Methods
+
+        Attribute::String.class_eval { include Methods }
+
+      end # class Length
+    end # module String
+  end # class Function
+end # module Axiom

data/lib/axiom/function/unary.rb

@@ -0,0 +1,124 @@
+# encoding: utf-8
+
+module Axiom
+  class Function
+
+      # Mixin for unary functions
+      module Unary
+        include Operation::Unary
+        include Equalizer.new(:operand)
+
+        # Mixin for adding #call to unary function classes
+        module Callable
+
+          # Hook called when module is included
+          #
+          # @param [Module] descendant
+          #   the module or class including Callable
+          #
+          # @return [self]
+          #
+          # @api private
+          def included(descendant)
+            super
+            descendant.extend(Callable)
+            self
+          end
+
+          # Return the response from the unary operation called on the value
+          #
+          # @example
+          #   callable.call(value)  # => any object
+          #
+          # @param [Object] value
+          #
+          # @return [Object]
+          #
+          # @api public
+          def call(value)
+            value.send(operation)
+          end
+
+        end # module Callable
+
+        extend Callable
+
+        # Evaluate the unary connective using the tuple
+        #
+        # @example
+        #   unary.call(tuple)  # => true or false
+        #
+        # @param [Tuple] tuple
+        #   the tuple to pass to operand#call
+        #
+        # @return [Boolean]
+        #
+        # @api public
+        def call(tuple)
+          util = self.class
+          util.call(util.extract_value(operand, tuple))
+        end
+
+        # Rename the contained attributes with the provided aliases
+        #
+        # @example
+        #   renamed = unary.rename(aliases)
+        #
+        # @param [Algebra::Rename::Aliases] aliases
+        #   the old and new attributes
+        #
+        # @return [self]
+        #   if the operand is not renamed
+        # @return [Unary]
+        #   if the operand is renamed
+        #
+        # @todo handle case where operand is a literal
+        #
+        # @api public
+        def rename(aliases)
+          util            = self.class
+          renamed_operand = util.rename_attributes(operand, aliases)
+
+          if operand.equal?(renamed_operand)
+            self
+          else
+            util.new(renamed_operand)
+          end
+        end
+
+        # Mixin for invertable unary functions
+        module Invertible
+
+          # Hook called when module is included
+          #
+          # @param [Module] descendant
+          #   the module or class including Invertible
+          #
+          # @return [undefined]
+          #
+          # @api private
+          def self.included(descendant)
+            super
+            descendant.memoize :inverse
+          end
+
+          private_class_method :included
+
+          # Return the inverse function
+          #
+          # @example
+          #   inverse = function.inverse
+          #
+          # @return [Function]
+          #
+          # @todo move this to classes that use it
+          #
+          # @api public
+          def inverse
+            self.class.inverse.new(operand).memoize(:inverse, self)
+          end
+
+        end # module Invertible
+      end # module Unary
+  end # class Function
+end # module Axiom

data/lib/axiom/relation.rb

@@ -0,0 +1,268 @@
+# encoding: utf-8
+
+module Axiom
+
+  # Abstract base class for Relation operations
+  class Relation
+    include Enumerable, Visitable
+    include Equalizer.new(:header, :to_set)
+
+    # The relation header
+    #
+    # @return [Header]
+    #
+    # @api private
+    attr_reader :header
+
+    # The relation tuples
+    #
+    # @return [Enumerable]
+    #
+    # @api private
+    attr_reader :tuples
+    private :tuples
+
+    # The relation sort order
+    #
+    # @return [Operation::Order::DirectionSet]
+    #
+    # @api private
+    def directions
+      Operation::Order::DirectionSet::EMPTY
+    end
+
+    # Instantiate a new Relation
+    #
+    # @example of a materialized Array based relation
+    #   array    = [ [ 1 ], [ 2 ], [ 3 ] ]
+    #   relation = Relation.new([ [ :id, Integer ] ], array)
+    #
+    # @example of a materialized Set based relation
+    #   set      = Set[ [ 1 ], [ 2 ], [ 3 ] ]
+    #   relation = Relation.new([ [ :id, Integer ] ], set)
+    #
+    # @example of a non-materialized Enumerator based relation
+    #   enumerator = [ [ 1 ], [ 2 ], [ 3 ] ].each
+    #   relation   = Relation.new([ [ :id, Integer ] ], enumerator)
+    #
+    # @param [Array(Header, Enumerable)] args
+    #
+    # @return [Relation]
+    #
+    # @api public
+    def self.new(*args)
+      last = args.last
+      if superclass.equal?(Object) && last.respond_to?(:size) && last.size.kind_of?(Integer)
+        Materialized.new(*args)
+      else
+        super
+      end
+    end
+
+    # Initialize a Relation
+    #
+    # @param [Header, #to_ary] header
+    #   the relation header
+    # @param [Enumerable] tuples
+    #   the relation tuples
+    #
+    # @return [undefined]
+    #
+    # @api private
+    def initialize(header, tuples)
+      @header = Header.coerce(header)
+      @tuples = freeze_object(tuples)
+    end
+
+    # Lookup an Attribute in the header given an attribute name
+    #
+    # @example
+    #   attribute = relation[name]
+    #
+    # @param [#to_sym] name
+    #   the attribute name
+    #
+    # @return [Attribute]
+    #
+    # @api public
+    def [](name)
+      header[name]
+    end
+
+    # Iterate over each tuple in the set
+    #
+    # @example
+    #   relation = Relation.new(header, tuples)
+    #   relation.each { |tuple| ... }
+    #
+    # @yield [tuple]
+    #
+    # @yieldparam [Tuple] tuple
+    #   each tuple in the set
+    #
+    # @return [self]
+    #
+    # @api public
+    def each
+      return to_enum unless block_given?
+      seen = Hash.new
+      tuples.each do |tuple|
+        tuple = Tuple.coerce(header, tuple)
+        yield seen[tuple] = tuple unless seen.key?(tuple)
+      end
+      self
+    end
+
+    # Return a tuple if the relation contains exactly one tuple
+    #
+    # @example
+    #   tuple = relation.one
+    #
+    # @return [Tuple]
+    #
+    # @raise [NoTuplesError]
+    #   raised if no tuples are returned
+    # @raise [ManyTuplesError]
+    #   raised if more than one tuple is returned
+    #
+    # @api public
+    def one
+      tuples = to_a
+      assert_exactly_one_tuple(tuples.size)
+      tuples.first
+    end
+
+    # Return a relation that represents a replacement of a relation
+    #
+    # Delete the tuples from the relation that are not in the other relation,
+    # then insert only new tuples.
+    #
+    # @example
+    #   replacement = relation.delete(other)
+    #
+    # @param [Enumerable] other
+    #
+    # @return [Relation::Operation::Insertion]
+    #
+    # @api public
+    def replace(other)
+      other = coerce(other)
+      delete(difference(other)).insert(other.difference(self))
+    end
+
+    # Return a relation with each tuple materialized
+    #
+    # @example
+    #   materialized = relation.materialize
+    #
+    # @return [Materialized]
+    #
+    # @api public
+    def materialize
+      Materialized.new(header, to_a, directions)
+    end
+
+    # Return false for a non-Materialized relation
+    #
+    # @example
+    #   relation.materialized?  # => false
+    #
+    # @return [false]
+    #
+    # @api public
+    def materialized?
+      false
+    end
+
+    # Test if the tuple exists in the relation
+    #
+    # @example
+    #   relation.include?(tuple)  # => true or false
+    #
+    # @param [Tuple] tuple
+    #
+    # @return [Boolean]
+    #
+    # @api public
+    def include?(tuple)
+      to_set.include?(tuple)
+    end
+
+    # Compare the relation with other relation for equivalency
+    #
+    # @example
+    #   relation == other  # => true or false
+    #
+    # @param [Relation] other
+    #   the other relation to compare with
+    #
+    # @return [Boolean]
+    #
+    # @api public
+    def ==(other)
+      other = coerce(other)
+      header == other.header &&
+      to_set == other.to_set
+    end
+
+    # Test if there are no tuples
+    #
+    # @example
+    #   relation.empty?  # => true or false
+    #
+    # @return [Boolean]
+    #
+    # @api public
+    def empty?
+      none?
+    end
+
+  private
+
+    # Coerce an Enumerable into a Relation
+    #
+    # @param [Enumerable] object
+    #   the object to coerce
+    #
+    # @return [Relation]
+    #
+    # @api private
+    def coerce(object)
+      self.class.coerce(header, object)
+    end
+
+    # Coerce an Enumerable into a Relation
+    #
+    # @param [Header] header
+    #   the header to use when initializing a Relation
+    # @param [Enumerable] object
+    #   the object to coerce
+    #
+    # @return [Relation]
+    #
+    # @api private
+    def self.coerce(header, object)
+      object.kind_of?(Relation) ? object : Relation.new(header, object)
+    end
+
+    # Assert exactly one tuple is returned
+    #
+    # @return [undefined]
+    #
+    # @raise [NoTuplesError]
+    #   raised if no tuples are returned
+    # @raise [ManyTuplesError]
+    #   raised if more than one tuple is returned
+    #
+    # @api private
+    def assert_exactly_one_tuple(size)
+      if size.zero?
+        raise NoTuplesError, 'one tuple expected, but was an empty set'
+      elsif size > 1
+        raise ManyTuplesError,
+          "one tuple expected, but set contained #{size} tuples"
+      end
+    end
+
+  end # class Relation
+end # module Axiom