locomotive 0.0.1

data/lib/locomotive.rb

@@ -0,0 +1,6 @@
+require "singleton"
+require "locomotive/misc"
+require "locomotive/core_extensions"
+require "locomotive/tree_helpers"
+require "locomotive/utils"
+require "locomotive/relational_algebra"

data/lib/locomotive/core_extensions.rb

@@ -0,0 +1,6 @@
+require "locomotive/core_extensions/class.rb"
+require "locomotive/core_extensions/module.rb"
+require "locomotive/core_extensions/array.rb"
+require "locomotive/core_extensions/hash.rb"
+require "locomotive/core_extensions/inflector.rb"
+require "locomotive/core_extensions/symbol.rb"

data/lib/locomotive/core_extensions/array.rb

@@ -0,0 +1,22 @@
+class Array
+  # Extracts options from a set of arguments. Removes and returns the last
+  # element in the array if it's a hash, otherwise returns a blank hash.
+  #
+  #   def options(*args)
+  #     args.extract_options!
+  #   end
+  #
+  #   options(1, 2)           # => {}
+  #   options(1, 2, :a => :b) # => {:a=>:b}
+  def extract_options!
+    last.is_a?(::Hash) ? pop : {}
+  end
+
+  def flatten_once
+    inject([]) { |v, e| v.concat(e)}
+  end 
+
+  def to_hash
+    Hash[*self.flatten_once]
+  end
+end

data/lib/locomotive/core_extensions/class.rb

@@ -0,0 +1,47 @@
+class Class
+  def cattr_reader(*syms)
+    syms.flatten.each do |sym|
+      next if sym.is_a?(Hash)
+      class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+        unless defined? @@#{sym}  # unless defined? @@hair_colors
+          @@#{sym} = nil          #   @@hair_colors = nil
+        end                       # end
+                                  #
+        def self.#{sym}           # def self.hair_colors
+          @@#{sym}                #   @@hair_colors
+        end                       # end
+                                  #
+        def #{sym}                # def hair_colors
+          @@#{sym}                #   @@hair_colors
+        end                       # end
+      EOS
+    end
+  end
+
+  def cattr_writer(*syms)
+    options = syms.extract_options!
+    syms.flatten.each do |sym|
+      class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+        unless defined? @@#{sym}                       # unless defined? @@hair_colors
+          @@#{sym} = nil                               #   @@hair_colors = nil
+        end                                            # end
+                                                       #
+        def self.#{sym}=(obj)                          # def self.hair_colors=(obj)
+          @@#{sym} = obj                               #   @@hair_colors = obj
+        end                                            # end
+                                                       #
+        #{"                                            #
+        def #{sym}=(obj)                               # def hair_colors=(obj)
+          @@#{sym} = obj                               #   @@hair_colors = obj
+        end                                            # end
+        " unless options[:instance_writer] == false }  # # instance writer above is generated unless options[:instance_writer] == false
+      EOS
+      self.send("#{sym}=", yield) if block_given?
+    end
+  end
+
+  def cattr_accessor(*syms, &blk)
+    cattr_reader(*syms)
+    cattr_writer(*syms, &blk)
+  end
+end

data/lib/locomotive/core_extensions/hash.rb

@@ -0,0 +1,7 @@
+class Hash
+  def flip
+    self.collect do |k,v|
+      [v,k]
+    end.to_hash
+  end
+end

data/lib/locomotive/core_extensions/inflector.rb

@@ -0,0 +1,29 @@
+module FerryCore
+
+  module Inflector
+    extend self
+
+    #  Converts the string to UpperCamelCase
+    def camelize(lower_case_and_underscored_word, first_letter_in_uppercase = true)
+      str = lower_case_and_underscored_word.to_s
+      if first_letter_in_uppercase then
+        str.gsub(/\/(.?)/) { "::#{$1.upcase}" }.
+            gsub(/(?:^|_)(.)/) { $1.upcase }
+      else
+        str[0].chr.downcase + 
+               camelize(lower_case_and_underscored_word)[1..-1]
+      end   
+    end
+
+    # the reverse to camelcase
+    def underscore(camel_cased_word)
+      camel_cased_word.to_s.gsub(/::/, '/').
+        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+        gsub(/([a-z\d])([A-Z])/,'\1_\2').
+        tr("-", "_").
+      downcase
+    end 
+
+  end
+
+end

data/lib/locomotive/core_extensions/module.rb

@@ -0,0 +1,77 @@
+module FerryCore
+
+  # extensions to enhance an object with some attributes
+  # and derive simple methods
+  module ModuleExtensions
+    private
+
+    def derive(method_name)
+      methods = {
+        :initialize => "
+           def #{method_name}(#{@attributes.join(',')})
+             #{@attributes.collect { |a| "@#{a} = #{a}" }.join("\n")}
+           end", 
+        :== => "
+           def ==(other)
+             #{name} === other &&
+             #{@attributes.collect { |a| "@#{a} == other.#{a}" }.join(" &&\n")}
+           end"
+      }
+      class_eval methods[method_name], __FILE__, __LINE__
+    end
+
+    public 
+
+    # extend the instance with some new attributes
+    def attributes(*attrs)
+      @attributes = attrs
+      attr_reader(*attrs)
+    end
+
+    def deriving(*methods)
+      methods.each(&method(:derive))
+    end
+
+    # stolen from active_support
+    # reimplement it by time since it use deprecated string metaprogramming
+    def delegate(*methods)
+      options = methods.pop
+      unless options.is_a?(Hash) && to = options[:to]
+        raise ArgumentError, "Delegation needs a target. Supply an options hash with a :to key as the last argument (e.g. delegate :hello, :to => :greeter)."
+      end
+  
+      if options[:prefix] == true && options[:to].to_s =~ /^[^a-z_]/
+        raise ArgumentError, "Can only automatically set the delegation prefix when delegating to a method."
+      end
+  
+      prefix = options[:prefix] && "#{options[:prefix] == true ? to : options[:prefix]}_"
+  
+      file, line = caller.first.split(':', 2)
+      line = line.to_i
+  
+      methods.each do |method|
+        on_nil =
+          if options[:allow_nil]
+            'return'
+          else
+            %(raise "#{self}##{prefix}#{method} delegated to #{to}.#{method}, but #{to} is nil: \#{self.inspect}")
+          end
+  
+        module_eval(<<-EOS, file, line)
+          def #{prefix}#{method}(*args, &block)               # def customer_name(*args, &block)
+            #{to}.__send__(#{method.inspect}, *args, &block)  #   client.__send__(:name, *args, &block)
+          rescue NoMethodError                                # rescue NoMethodError
+            if #{to}.nil?                                     #   if client.nil?
+              #{on_nil}
+            else                                              #   else
+              raise                                           #     raise
+            end                                               #   end
+          end                                                 # end
+        EOS
+      end
+    end
+
+    Module.send :include, self
+  end
+
+end

data/lib/locomotive/core_extensions/symbol.rb

@@ -0,0 +1,17 @@
+module FerryCore
+
+  module SymbolExtensions
+
+    def classify
+      Inflector::camelize(self).to_sym
+    end
+
+    def methify
+      Inflector::underscore(
+        self.to_s.split("::").last).to_sym
+    end
+
+    Symbol.send :include, self
+  end
+
+end

data/lib/locomotive/misc.rb

@@ -0,0 +1 @@
+require 'locomotive/misc/type_check'

data/lib/locomotive/misc/type_check.rb

@@ -0,0 +1,129 @@
+module Locomotive
+
+module TypeChecking
+
+class ArgumentError < StandardError; end
+
+#
+# Type checking method parameters
+# 
+module TypeChecker
+
+  private
+  
+  def nth n
+    n_ = n + 1
+    th = case n_
+           when 1 then 'st'
+           when 2 then 'nd'
+           else        'th'
+         end
+    "#{n_}#{th}"
+  end
+
+  public
+
+  # check a simple argument type
+  def check_arg_type(expected, obj, mtd, n=0)
+    unless obj.kind_of? expected
+      raise ArgumentError,
+            "#{obj.class} assigned to #{expected} " \
+            "for the #{nth n} argument of #{mtd}."
+    end
+  end
+
+  # check an array type
+  def check_arg_array_type(elem_type, arg, mtd, n=0)
+    check_arg_type Array, arg, mtd, n
+    arg.each_with_index do |x,i|
+      unless x.kind_of? elem_type
+        raise ArgumentError,
+              "#{x.class} assigned to #{elem_type} for " \
+              "the #{nth n} element of the #{nth n} "    \
+              "argument of #{mtd}."
+      end
+    end
+  end
+
+  # check a hash type
+  def check_arg_hash_type(key_type, elem_type, arg, mtd, n=0)
+    check_arg_type Hash, arg, mtd, n
+    arg.each_with_index do |item,i|
+      check_arg_type key_type, item.first, mtd, n
+      check_arg_type elem_type, item.last, mtd, n if elem_type.kind_of? Class
+      check_arg_array_type elem_type.first, item.last, mtd, n if elem_type.kind_of? Array
+    end
+  end
+
+  # check a variable argument type
+  def check_vararg_type(expected, args, mtd, n=0)
+    (n..args.length).each do |i|
+      check_arg_type expected, args[i], mtd, i
+    end
+  end
+
+  # make 'class'-methods out of the
+  # methods defined above
+  extend self
+end
+
+#
+# Add declarative signature support
+#
+module Signature
+
+  private
+
+  def intercept_method(sym, types)
+    # get the unbound method object
+    mtd = instance_method(sym)
+    helper = "_#{sym}_param_types_checked_helper".to_sym
+
+    define_method(helper) do |*params|
+      star_type, star_ind = nil, nil
+      types.each_with_index do |t,i|
+        t = star_type unless star_type.nil?
+        arg = params[i]
+        if t.kind_of? Class
+          TypeChecker.check_arg_type t, arg, sym, i
+        elsif t.empty?
+          TypeChecker.check_arg_type Array, arg, sym, i
+        elsif t.kind_of? Array
+          TypeChecker.check_arg_array_type t[0], arg, sym, i
+        elsif t.kind_of? Hash
+          TypeChecker.check_arg_hash_type t.first.first,
+                                          t.first.last,
+                                          arg, sym, i
+        else
+          star_type, star_ind = t[0], i
+          break
+        end
+      end
+      TypeChecker.check_vararg_type star_type, params, sym, star_ind unless star_ind.nil?
+      mtd.bind(self)
+    end
+    module_eval do
+      define_method(sym) do |*params, &block|
+        method(helper).call(*params).call(*params, &block)
+      end
+    end
+  end
+
+  public
+
+  def def_sig sym, *types
+    types.each_with_index do |t,i|
+      unless t.kind_of? Class
+        TypeChecker.check_arg_type Class, t, :def_sig, i unless t.kind_of? Array or t.kind_of? Hash
+        TypeChecker.check_arg_type Class, t, :def_sig, i unless t.length <= 1
+        TypeChecker.check_arg_array_type Class, t, :def_sig, i if t.kind_of? Array
+      end
+    end
+    intercept_method(sym, types)
+  end
+  Module.send(:include, self)
+end
+
+end
+
+end

data/lib/locomotive/relational_algebra.rb

@@ -0,0 +1,8 @@
+require 'locomotive/relational_algebra/rel_alg_ast_node'
+require 'locomotive/relational_algebra/rel_alg_exceptions'
+require 'locomotive/relational_algebra/attributes'
+require 'locomotive/relational_algebra/types'
+require 'locomotive/relational_algebra/schema'
+require 'locomotive/relational_algebra/ordering'
+require 'locomotive/relational_algebra/operators'
+require 'locomotive/relational_algebra/query_information'

data/lib/locomotive/relational_algebra/attributes.rb

@@ -0,0 +1,171 @@
+module Locomotive
+
+  module RelationalAlgebra
+
+
+    class GenericAttribute; end
+  
+    class ConstAttribute < GenericAttribute
+      protected
+    
+      def nth id
+        if id == 0
+          ""
+        else
+           id.to_s
+        end
+      end 
+
+      # we only accept positive integers as ids
+      def id=(id)
+        raise IdError, "#{id} less than 0" if id < 0
+        @id = id 
+      end
+      def_sig :id=, Fixnum
+     
+      public
+     
+      attr_reader :id
+     
+      def initialize(id=0)
+        raise AbstractClassError,
+              "#{self.class} is an abstract class" if self.class == ConstAttribute
+        self.id = id
+      end
+    
+   
+      def inc(val=1)
+        self.class.new(self.id + val)
+      end
+     
+      def to_xml
+        # Be careful of classes that are nested in modules
+        "#{self.class.to_s.split("::").last.downcase}#{nth id}".to_sym
+      end
+    
+      # Equality for attributes is defined over
+      # their class and id
+      def ==(other)
+        self.class == other.class and
+        self.id == other.id
+      end
+    
+      module HashKeys
+        # We want to use attributes as keys
+        # for a hash-object, so we have to
+        # overwrite the eql?- and hash-method
+        # to make it work 
+        def eql?(other)
+          self.==(other)
+        end
+        def_sig :eql?, ConstAttribute
+    
+        def hash
+          # not the best algorithm for calculating a
+          # hash but it works quite well
+          self.class.object_id + id.object_id
+        end
+      end
+      include HashKeys
+    
+      def clone
+        # an attributes contains only an id
+        self.class.new(id)
+      end
+    
+      def inspect
+        "<#{self.class.to_s.split('::').last} #{id}>"
+      end
+    end
+    
+    class Iter < ConstAttribute; end
+    def Iter(id)
+      Iter.new(id)
+    end
+    class Outer < Iter; end
+    def Outer(id)
+      Outer.new(id)
+    end
+    class Inner < Iter; end
+    def Inner(id)
+      Inner.new(id)
+    end
+    class Pos < ConstAttribute; end
+    def Pos(id)
+      Pos.new(id)
+    end
+    class Item < ConstAttribute
+
+      include Comparable
+      def <=>(other)
+        self.id <=> other.id
+      end
+      def_sig :<=>, Item
+
+      def inc!(id)
+        self.id += id
+      end
+  
+      def dec!(id)
+        self.id -= id 
+      end
+    
+    end
+    def Item(id)
+      Item.new(id)
+    end
+
+    class Attribute < GenericAttribute
+      attr_reader :name
+     
+      def initialize(name)
+        @name = name.to_s
+      end
+    
+      # Equality for attributes is defined over
+      # their class their name
+      def ==(other)
+        self.class == other.class and
+        self.name == other.name
+      end
+    
+      module HashKeys
+        # We want to use attributes as keys
+        # for a hash-object, so we have to
+        # overwrite the eql?- and hash-method
+        # to make it work 
+        def eql?(other)
+          self.==(other)
+        end
+        def_sig :eql?, Attribute
+      
+        def hash
+          # not the best algorithm for calculating a
+          # hash but it works quite well
+          self.class.object_id + name.object_id
+        end
+      end
+      include HashKeys
+
+      def to_xml
+        # Be careful of classes that are nested in modules
+        name
+      end
+ 
+    
+      def inspect
+        "<#{self.class.to_s.split('::').last} name:#{name}>"
+      end
+    
+      def clone
+        # an attributes contains only an id
+        Attribute.new(name)
+      end
+    end
+    def Attribute(name)
+      Attribute.new(name)
+    end
+  
+  end
+
+end