alf 0.12.2 → 0.13.0

data/lib/alf/reader/instance_methods.rb

@@ -1,97 +0,0 @@
-module Alf
-  class Reader
-    module InstanceMethods
-
-      # Default reader options
-      DEFAULT_OPTIONS = {}
-
-      # @return [Environment] Wired environment 
-      attr_accessor :environment
-
-      # @return [String or IO] Input IO, or file name
-      attr_accessor :input
-
-      # @return [Hash] Reader's options
-      attr_accessor :options
-
-      # Creates a reader instance. 
-      #
-      # @param [String or IO] path to a file or IO object for input
-      # @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 String, IO, StringIO
-          Tools.varargs(args, [args.first.class, Environment, Hash])
-        else
-          Tools.varargs(args, [String, Environment, Hash])
-        end
-        @options = self.class.const_get(:DEFAULT_OPTIONS).merge(@options || {}) 
-      end
-
-      # (see Iterator#each)
-      #
-      # @private the default implementation reads lines of the input stream and 
-      # yields the block with <code>line2tuple(line)</code> on each of them. This 
-      # method may be overriden if this behavior does not fit reader's needs.
-      def each
-        each_input_line do |line| 
-          tuple = line2tuple(line)
-          yield tuple unless tuple.nil?
-        end
-      end
-
-      protected
-
-      # @return the input file path, or nil if this Reader is bound to an IO
-      # directly.
-      def input_path
-        input.is_a?(String) ? input : nil
-      end
-
-      # Coerces the input object to an IO and yields the block with it.
-      #
-      # StringIO and IO input are yield directly while file paths are first
-      # opened in read mode and then yield.
-      def with_input_io
-        case input
-        when IO, StringIO
-          yield input
-        when String
-          File.open(input, 'r'){|io| yield io}
-        else
-          raise "Unable to convert #{input} to an IO object"
-        end
-      end
-
-      # Returns the whole input text. 
-      #
-      # This feature should only be used by subclasses on inputs that are 
-      # small enough to fit in memory. Consider implementing readers without this
-      # feature on files that could be larger. 
-      def input_text
-        with_input_io{|io| io.readlines.join}
-      end
-
-      # Yields the block with each line of the input text in turn.
-      #
-      # This method is an helper for files that capture one tuple on each input 
-      # line. It should be used in those cases, as the resulting reader will not
-      # load all input in memory but serve tuples on demand.  
-      def each_input_line
-        with_input_io{|io| io.each_line(&Proc.new)}
-      end
-
-      # Converts a line previously read from the input stream to a tuple. 
-      #
-      # The line is simply ignored is this method return nil. Errors should be
-      # properly handled by raising exceptions. This method MUST be implemented 
-      # by subclasses unless each is overriden.
-      def line2tuple(line)
-      end
-      undef :line2tuple
-
-    end # module InstanceMethods
-    include InstanceMethods
-  end # class Reader
-end # module Alf

data/lib/alf/reader/rash.rb

@@ -1,28 +0,0 @@
-module Alf
-  class Reader
-    #
-    # Specialization of the Reader contract for .rash files.
-    #
-    # A .rash file/stream contains one ruby hash literal on each line. This 
-    # reader simply decodes each of them in turn with Kernel.eval, providing a 
-    # state-less reader (that is, tuples are not all loaded in memory at once).
-    #
-    class Rash < Reader
-
-      # (see Reader#line2tuple)
-      def line2tuple(line)
-        begin
-          h = Kernel.eval(line)
-          raise "hash expected, got #{h}" unless h.is_a?(Hash)
-        rescue Exception => ex
-          $stderr << "Skipping #{line.strip}: #{ex.message}\n"
-          nil
-        else
-          return h
-        end
-      end
-
-      Reader.register(:rash, [".rash"], self)
-    end # class Rash
-  end # class Reader
-end # module Alf

data/lib/alf/relation.rb

@@ -1,28 +0,0 @@
-module Alf
-  #
-  # Defines an in-memory relation data structure.
-  #
-  # A relation is a set of tuples; a tuple is a set of attribute (name, value)
-  # pairs. The class implements such a data structure with full relational
-  # algebra installed as instance methods.
-  #
-  # Relation values can be obtained in various ways, for example by invoking
-  # a relational operator on an existing relation. Relation literals are simply
-  # constructed as follows:
-  #
-  #     Alf::Relation[
-  #       # ... a comma list of ruby hashes ...
-  #     ]
-  #
-  # See main Alf documentation about relational operators.
-  #
-  class Relation
-    include Iterator
-
-    require "alf/relation/class_methods"
-    require "alf/relation/instance_methods"
-
-    DEE = Relation.coerce([{}])
-    DUM = Relation.coerce([])
-  end # class Relation
-end # module Alf

data/lib/alf/relation/class_methods.rb

@@ -1,28 +0,0 @@
-module Alf
-  class Relation
-    module ClassMethods
-      
-      #
-      # Coerces `val` to a relation.
-      #
-      # Recognized arguments are: Relation (identity coercion), Set of ruby hashes, 
-      # Array of ruby hashes, Alf::Iterator.
-      #
-      # @return [Relation] a relation instance for the given set of tuples
-      # @raise [ArgumentError] when `val` is not recognized
-      #
-      def coerce(val)
-        Alf::Tools.to_relation(val)
-      rescue Myrrha::Error
-        raise ArgumentError, "Unable to coerce `#{val}` to a Relation"
-      end
-      
-      # (see Relation.coerce)
-      def [](*tuples)
-        coerce(tuples)
-      end
-      
-    end # module ClassMethods
-    extend(ClassMethods)
-  end # class Relation
-end # module Alf

data/lib/alf/relation/instance_methods.rb

@@ -1,119 +0,0 @@
-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.unshift([self]))
-            Relation.coerce(op)
-          end
-        elsif op_class.binary?
-          define_method(meth_name) do |right, *args|
-            op = op_class.new(*args.unshift([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 json representation of this Relation.
-      def to_json(*args)
-        to_a.to_json(*args)
-      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
-
-      # Returns self
-      def to_relation
-        self
-      end
-
-    end # module InstanceMethods
-    include(InstanceMethods)
-  end # class Relation
-end # module Alf

data/lib/alf/renderer.rb

@@ -1,32 +0,0 @@
-module Alf
-  #
-  # Renders a relation (given by any Iterator) in a specific format.
-  #
-  # A renderer takes an Iterator instance as input and renders it on an output
-  # stream. Renderers are **not** iterators themselves. Their usage is made 
-  # via their {#execute} method.
-  #
-  # Similarly to the {Reader} class, this one provides a registration mechanism
-  # for specific output formats. The common scenario is as follows:
-  #
-  #   # Register a new renderer for :foo format (automatically provides the 
-  #   # '--foo   Render output as a foo stream' option of 'alf show') and with
-  #   # the FooRenderer class for handling rendering.  
-  #   Renderer.register(:foo, "as a foo stream", FooRenderer)
-  #
-  #   # Later on, you can request a renderer instance for a specific format
-  #   # as follows (wiring input is optional) 
-  #   r = Renderer.renderer(:foo, [an Iterator])
-  #
-  #   # Also, a factory method is automatically installed on the Renderer class
-  #   # itself.
-  #   r = Renderer.foo([an Iterator])
-  #
-  class Renderer
-    require 'alf/renderer/class_methods'
-    require 'alf/renderer/instance_methods'
-    require 'alf/renderer/rash'
-    require 'alf/renderer/text'
-
-  end # class Renderer
-end # module Alf

data/lib/alf/renderer/class_methods.rb

@@ -1,58 +0,0 @@
-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/instance_methods.rb

@@ -1,55 +0,0 @@
-module Alf
-  class Renderer
-    module InstanceMethods
-
-      # 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
-
-      # 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 InstanceMethods
-    include InstanceMethods
-  end # class Renderer
-end # module Alf