alf 0.9.3 → 0.10.0

data/lib/alf/relation/instance_methods.rb

@@ -0,0 +1,127 @@
+module Alf
+  class Relation
+    module InstanceMethods
+
+      protected
+      
+      # @return [Set] the set of tuples
+      attr_reader :tuples
+      
+      public
+      
+      #
+      # Creates a Relation instance.
+      #
+      # @param [Set] tuples a set of tuples
+      #
+      def initialize(tuples)
+        raise ArgumentError unless tuples.is_a?(Set)
+        @tuples = tuples
+      end
+      
+      #
+      # (see Iterator#each)
+      #
+      def each(&block)
+        tuples.each(&block)
+      end
+      
+      #
+      # Returns relation's cardinality (number of tuples).
+      #
+      # @return [Integer] relation's cardinality 
+      # 
+      def cardinality
+        tuples.size
+      end
+      alias :size :cardinality
+      alias :count :cardinality
+      
+      # Returns true if this relation is empty
+      def empty?
+        cardinality == 0
+      end
+      
+      # 
+      # Install the DSL through iteration over defined operators
+      #
+      Operator::each do |op_class|
+        meth_name = Tools.ruby_case(Tools.class_name(op_class)).to_sym
+        if op_class.unary?
+          define_method(meth_name) do |*args|
+            op = op_class.new(*args).pipe(self)
+            Relation.coerce(op)
+          end
+        elsif op_class.binary?
+          define_method(meth_name) do |right, *args|
+            op = op_class.new(*args).pipe([self, Iterator.coerce(right)])
+            Relation.coerce(op)
+          end
+        elsif op_class.nullary?
+          define_method(meth_name) do |*args|
+            op = op_class.new(*args)
+            Relation.coerce(op)
+          end
+        else
+          raise "Unexpected operator #{op_class}"
+        end
+      end # Operators::each
+        
+      alias :+ :union
+      alias :- :minus
+  
+      # Shortcut for project(attributes, :allbut => true)
+      def allbut(attributes)
+        project(attributes, :allbut => true)
+      end
+          
+      #
+      # (see Object#hash)
+      #
+      def hash
+        @tuples.hash
+      end
+      
+      #
+      # (see Object#==)
+      #
+      def ==(other)
+        return nil unless other.is_a?(Relation)
+        other.tuples == self.tuples
+      end
+      alias :eql? :==
+      
+      #
+      # Returns a textual representation of this relation
+      #
+      def to_s
+        Alf::Renderer.text(self).execute("")
+      end
+      
+      #
+      # Returns an array with all tuples in this relation.
+      #
+      # @param [Tools::Ordering] an optional ordering key (any argument 
+      #        recognized by Ordering.coerce is supported here). 
+      # @return [Array] an array of hashes, in requested order (if specified)
+      #
+      def to_a(okey = nil)
+        okey = Tools.coerce(okey, Ordering) if okey
+        ary = tuples.to_a
+        ary.sort!(&okey.sorter) if okey
+        ary
+      end
+      
+      #
+      # Returns a  literal representation of this relation
+      #
+      def to_ruby_literal
+        "Alf::Relation[" +
+          tuples.collect{|t| Tools.to_ruby_literal(t)}.join(', ') + "]"
+      end
+      alias :inspect :to_ruby_literal
+      
+    end # module InstanceMethods
+    include(InstanceMethods)
+  end # class Relation
+end # module Alf

data/lib/alf/renderer/base.rb

@@ -0,0 +1,72 @@
+module Alf
+  class Renderer
+    module Base
+      
+      # Default renderer options
+      DEFAULT_OPTIONS = {}
+  
+      # Renderer input (typically an Iterator)
+      attr_accessor :input
+      
+      # @return [Environment] Optional wired environment
+      attr_accessor :environment
+  
+      # @return [Hash] Renderer's options
+      attr_accessor :options
+      
+      #
+      # Creates a reader instance. 
+      #
+      # @param [Iterator] iterator an Iterator of tuples to render
+      # @param [Environment] environment wired environment, serving this reader
+      # @param [Hash] options Reader's options (see doc of subclasses) 
+      #
+      def initialize(*args)
+        @input, @environment, @options = case args.first
+        when Array
+          Tools.varargs(args, [Array, Environment, Hash])
+        else
+          Tools.varargs(args, [Iterator, Environment, Hash])
+        end
+        @options = self.class.const_get(:DEFAULT_OPTIONS).merge(@options || {}) 
+      end
+      
+      # 
+      # Sets the renderer input.
+      #
+      # This method mimics {Iterator#pipe} and have the same contract.
+      #
+      def pipe(input, env = environment)
+        self.environment = env 
+        self.input = input
+        self
+      end
+  
+      #
+      # Executes the rendering, outputting the resulting tuples on the provided
+      # output buffer. 
+      #
+      # The default implementation simply coerces the input as an Iterator and
+      # delegates the call to {#render}.
+      #
+      def execute(output = $stdout)
+        render(Iterator.coerce(input, environment), output)
+      end
+      
+      protected
+      
+      #
+      # Renders tuples served by the iterator to the output buffer provided and
+      # returns the latter.
+      #
+      # This method must be implemented by subclasses unless {#execute} is 
+      # overriden.
+      #
+      def render(iterator, output)
+      end
+      undef :render
+      
+    end # module Base
+    include Base
+  end # class Renderer
+end # module Alf

data/lib/alf/renderer/class_methods.rb

@@ -0,0 +1,58 @@
+module Alf
+  class Renderer
+    module ClassMethods
+      
+      #
+      # Returns registered renderers
+      #
+      def renderers 
+        @renderers ||= []
+      end
+      
+      #
+      # Register a renderering class with a given name and description.
+      #
+      # Registered class must at least provide a constructor with an empty 
+      # signature. The name must be a symbol which can safely be used as a ruby 
+      # method name. A factory class method of that name and degelation signature 
+      # is automatically installed on the Renderer class.
+      #
+      # @param [Symbol] name a name for the output format
+      # @param [String] description an output format description (for 'alf show')
+      # @param [Class] clazz Renderer subclass used to render in this format 
+      #     
+      def register(name, description, clazz)
+        renderers << [name, description, clazz]
+        (class << self; self; end).
+          send(:define_method, name) do |*args|
+            clazz.new(*args)
+          end
+      end
+      
+      #
+      # Returns a Renderer instance for the given output format name.
+      #
+      # @param [Symbol] name name of an output format previously registered
+      # @param [...] args other arguments to pass to the renderer constructor
+      # @return [Renderer] a Renderer instance, already wired if args are 
+      #         provided
+      #
+      def renderer(name, *args)
+        if r = renderers.find{|triple| triple[0] == name}
+          r[2].new(*args)
+        else
+          raise "No renderer registered for #{name}"
+        end
+      end
+  
+      #
+      # Yields each (name,description,clazz) previously registered in turn
+      #
+      def each_renderer
+        renderers.each(&Proc.new)
+      end
+      
+    end # module ClassMethods
+    extend(ClassMethods)
+  end # class Renderer
+end # module Alf

data/lib/alf/renderer/rash.rb

@@ -0,0 +1,19 @@
+module Alf
+  class Renderer
+    #
+    # Implements the Renderer contract through inspect
+    #
+    class Rash < Renderer
+  
+      # (see Renderer#render)
+      def render(input, output)
+        input.each do |tuple|
+          output << Tools.to_ruby_literal(tuple) << "\n"
+        end
+        output
+      end
+  
+      Renderer.register(:rash, "as ruby hashes", self)
+    end # class Rash
+  end # class Renderer
+end # module Alf

data/lib/alf/{text.rb → renderer/text.rb}

@@ -52,7 +52,7 @@ module Alf
             when Symbol
               value.inspect
             when Float
-              "%.7f" % value
+              "%.3f" % value
             when Hash
               value.inspect
             when Alf::Iterator

data/lib/alf/tools/coerce.rb

@@ -0,0 +1,14 @@
+module Alf
+  module Tools
+
+    # Coercion rules
+    Coercions = Myrrha::Coerce.dup.append do
+    end
+    
+    # Delegated to Coercions
+    def coerce(value, domain)
+      Coercions.apply(value, domain)
+    end
+    
+  end # module Tools
+end # module Alf

data/lib/alf/tools/miscellaneous.rb

@@ -0,0 +1,77 @@
+module Alf
+  module Tools
+    
+    
+    # Helper to define methods with multiple signatures. 
+    #
+    # Example:
+    #
+    #   varargs([1, "hello"], [Integer, String]) # => [1, "hello"]
+    #   varargs(["hello"],    [Integer, String]) # => [nil, "hello"]
+    # 
+    def varargs(args, types)
+      types.collect{|t| t===args.first ? args.shift : nil}
+    end
+    
+    #
+    # Attempt to require(who) the most friendly way as possible.
+    #
+    def friendly_require(who, dep = nil, retried = false)
+      gem(who, dep) if dep && defined?(Gem)
+      require who
+    rescue LoadError => ex
+      if retried
+        raise "Unable to require #{who}, which is now needed\n"\
+              "Try 'gem install #{who}'"
+      else
+        require 'rubygems' unless defined?(Gem)
+        friendly_require(who, dep, true)
+      end
+    end
+
+    # Returns the unqualified name of a ruby class or module
+    #
+    # Example
+    #
+    #   class_name(Alf::Tools) -> :Tools
+    #
+    def class_name(clazz)
+      clazz.name.to_s =~ /([A-Za-z0-9_]+)$/
+      $1.to_sym
+    end
+    
+    #
+    # Converts an unqualified class or module name to a ruby case method name.
+    #
+    # Example
+    #
+    #    ruby_case(:Alf)  -> "alf"
+    #    ruby_case(:HelloWorld) -> "hello_world"
+    # 
+    def ruby_case(s)
+      s.to_s.gsub(/[A-Z]/){|x| "_#{x.downcase}"}[1..-1]
+    end
+    
+    #
+    # Returns the first non nil values from arguments
+    #
+    # Example
+    #
+    #   coalesce(nil, 1, "abc") -> 1
+    #
+    def coalesce(*args)
+      found = args.find{|x| !x.nil?}
+      found.nil? ? (block_given? ? yield : nil) : found
+    end
+    
+    #
+    # Iterates over enum and yields the block on each element. 
+    # Collect block results as key/value pairs returns them as 
+    # a Hash.
+    #
+    def tuple_collect(enum)
+      Hash[enum.collect{|elm| yield(elm)}]
+    end
+
+  end # module Tools
+end # module Alf

data/lib/alf/tools/to_lispy.rb

@@ -0,0 +1,99 @@
+module Alf
+  module Tools
+
+    # Myrrha rules for converting to ruby literals
+    ToLispy = Myrrha::coercions do |r|
+      
+      # Delegate to #to_lispy if it exists
+      lispy_able = lambda{|v,rd| v.respond_to?(:to_lispy)}
+      r.upon(lispy_able) do |v,rd|
+        v.to_lispy
+      end
+
+      # On AttrList
+      r.upon(Types::AttrList) do |v, rd|
+        Tools.to_ruby_literal(v.attributes)
+      end
+
+      # On Heading
+      r.upon(Types::Heading) do |v, rd|
+        Tools.to_ruby_literal(v.attributes)
+      end
+
+      # On Ordering
+      r.upon(Types::Ordering) do |v, rd|
+        Tools.to_ruby_literal(v.ordering)
+      end
+
+      # On Renaming
+      r.upon(Types::Renaming) do |v, rd|
+        Tools.to_ruby_literal(v.renaming)
+      end
+
+      # On Renaming
+      r.upon(lambda{|v,rd| Iterator::Proxy === v}) do |v, rd|
+        Tools.to_ruby_literal(v.dataset)
+      end
+
+      # On TupleExpression
+      r.upon(Types::TupleExpression) do |v, rd|
+        unless src = v.source
+          raise NotImplementedError, "TupleExpression #{v} has no source"
+        end
+        "->(){ #{src} }"
+      end
+
+      # On TuplePredicate
+      r.upon(Types::TuplePredicate) do |v, rd|
+        unless src = v.source
+          raise NotImplementedError, "TuplePredicate #{v} has no source"
+        end
+        "->(){ #{src} }"
+      end
+
+      # On TupleComputation
+      r.upon(Types::TupleComputation) do |v, rd|
+        "{" + v.computation.collect{|name,compu|
+          [name.inspect, r.coerce(compu)].join(" => ")
+        }.join(', ') + "}"
+      end
+
+      # On Aggregator
+      r.upon(lambda{|v,_| Aggregator === v}) do |v, rd|
+        unless src = v.source
+          raise NotImplementedError, "Aggregator #{v} has no source"
+        end
+        src
+      end
+
+      # On Summarization
+      r.upon(Types::Summarization) do |v, rd|
+        "{" + v.aggregations.collect{|name,compu|
+          [name.inspect, r.coerce(compu)].join(" => ")
+        }.join(', ') + "}"
+      end
+
+      # On Command and Operator
+      cmd = lambda{|v,_| (Command === v) || (Operator === v)}
+      r.upon(cmd) do |v,rd|
+        cmdname  = v.class.command_name.to_s.gsub('-', '_')
+        oper, args, opts = v.class.signature.collect_on(v)
+        args = opts.empty? ? (oper + args) : (oper + args + [ opts ])
+        args = args.collect{|arg| r.coerce(arg)}
+        "(#{cmdname} #{args.join(', ')})"
+      end
+
+      # Let's assume to to_ruby_literal will make the job
+      r.fallback(Object) do |v, _|
+        Tools.to_ruby_literal(v)
+      end
+
+    end
+    
+    # Delegated to ToLispy
+    def to_lispy(value)
+      ToLispy.apply(value)
+    end
+    
+  end # module Tools
+end # module Alf

data/lib/alf/tools/to_ruby_literal.rb

@@ -0,0 +1,14 @@
+module Alf
+  module Tools
+
+    # Myrrha rules for converting to ruby literals
+    ToRubyLiteral = Myrrha::ToRubyLiteral.dup.append do
+    end
+    
+    # Delegated to ToRubyLiteral
+    def to_ruby_literal(value)
+      ToRubyLiteral.apply(value)
+    end
+    
+  end # module Tools
+end # module Alf

data/lib/alf/tools/tuple_handle.rb

@@ -0,0 +1,50 @@
+module Alf
+  module Tools
+    #
+    # Provides a handle, implementing a flyweight design pattern on tuples.
+    #
+    class TupleHandle
+    
+      # Creates an handle instance
+      def initialize
+        @tuple = nil
+      end
+    
+      #
+      # Sets the next tuple to use.
+      #
+      # This method installs the handle as a side effect 
+      # on first call. 
+      #
+      def set(tuple)
+        build(tuple) if @tuple.nil?
+        @tuple = tuple
+        self
+      end
+    
+      #
+      # Evaluates a tuple expression on the current tuple.
+      # 
+      def evaluate(expr)
+        TupleExpression.coerce(expr).evaluate(self)
+      end
+    
+      private
+    
+      #
+      # Builds this handle with a tuple.
+      #
+      # This method should be called only once and installs 
+      # instance methods on the handle with keys of _tuple_.
+      #
+      def build(tuple)
+        tuple.keys.each do |k|
+          (class << self; self; end).send(:define_method, k) do
+            @tuple[k]
+          end
+        end
+      end
+    
+    end # class TupleHandle
+  end # module Tools
+end # module Alf

data/lib/alf/types/attr_list.rb

@@ -0,0 +1,56 @@
+module Alf
+  module Types
+    #
+    # Defines a projection key
+    # 
+    class AttrList
+    
+      # Projection attributes
+      attr_accessor :attributes
+    
+      def initialize(attributes)
+        @attributes = attributes
+      end
+    
+      def self.coerce(arg)
+        case arg
+        when AttrList
+          arg
+        when Ordering
+          AttrList.new(arg.attributes)
+        when Array
+          AttrList.new(arg.collect{|s| Tools.coerce(s, AttrName)})
+        else
+          raise ArgumentError, "Unable to coerce #{arg} to a projection key"
+        end
+      end
+
+      def self.from_argv(argv, opts = {})
+        coerce(argv)
+      end
+          
+      def to_ordering
+        Ordering.new attributes.collect{|arg| [arg, :asc]}
+      end
+    
+      def project(tuple, allbut = false)
+        split(tuple, allbut).first
+      end
+    
+      def split(tuple, allbut = false)
+        projection, rest = {}, tuple.dup
+        attributes.each do |a|
+          projection[a] = tuple[a]
+          rest.delete(a)
+        end
+        allbut ? [rest, projection] : [projection, rest]
+      end
+
+      def ==(other)
+        other.is_a?(AttrList) && (other.attributes == attributes)          
+      end
+      alias :eql? :==
+      
+    end # class AttrList
+  end # module Types
+end # module Alf

data/lib/alf/types/attr_name.rb

@@ -0,0 +1,28 @@
+module Alf
+  module Types
+    #
+    # Data type for being a valid attribute name
+    #  
+    class AttrName < Symbol
+      extend Myrrha::Domain
+      
+      def self.predicate
+        @predicate ||= lambda{|s| s.to_s =~ /^[a-zA-Z0-9_]+$/}
+      end
+            
+      def self.coerce(arg)
+        if arg.respond_to?(:to_sym)
+          sym = arg.to_sym
+          return sym if self.===(sym) 
+        end
+        raise ArgumentError, "Unable to coerce `#{arg.inspect}` to AttrName"
+      end
+      
+      def self.from_argv(argv, opts = {})
+        raise ArgumentError if argv.size > 1
+        coerce(argv.first || opts[:default]) 
+      end
+      
+    end # class AttrName
+  end # module Types
+end # module Alf

data/lib/alf/types/boolean.rb

@@ -0,0 +1,12 @@
+module Alf
+  module Types
+    
+    Boolean = Myrrha::Boolean
+    
+    def Boolean.from_argv(argv, opts={})
+      raise ArgumentError if argv.size > 1
+      Tools.coerce(argv.first, Boolean)
+    end
+        
+  end
+end