alf-core 0.13.0

data/lib/alf-io/alf/reader/rash.rb

@@ -0,0 +1,32 @@
+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
+
+      def self.mime_type
+        nil
+      end
+
+      # (see Reader#line2tuple)
+      def line2tuple(line)
+        begin
+          h = Kernel.eval(line)
+          raise "Tuple expected, got #{h}" unless TupleLike===h
+        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-io/alf/renderer.rb

@@ -0,0 +1,119 @@
+module Alf
+  #
+  # Renders a relation iterator in a specific format.
+  #
+  # A renderer takes a tuple iterator as input and renders it on an output stream.
+  # 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
+    include Enumerable
+
+    class << self
+      include Support::Registry
+
+      #
+      # 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)
+        super([name, description, clazz], Renderer)
+      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 = registered.find{|triple| triple.first == name}
+          r.last.new(*args)
+        else
+          raise "No renderer registered for #{name}"
+        end
+      end
+
+      #
+      # Returns a Renderer instance for the given mime type.
+      #
+      # @param [String] mime_type a given (simplified) MIME type
+      # @param [...] args other arguments to pass to the renderer constructor
+      # @return [Renderer] a Renderer instance, already wired if args are provided
+      #
+      def by_mime_type(mime_type, *args)
+        if r = registered.find{|_,_,c| c.mime_type == mime_type}
+          r.last.new(*args)
+        else
+          raise UnsupportedMimeTypeError, "No renderer for `#{mime_type}`"
+        end
+      end
+
+    end # class << self
+
+    # Default renderer options
+    DEFAULT_OPTIONS = {}
+
+    # Renderer tuple iterator
+    attr_accessor :input
+
+    # @return [Hash] Renderer's options
+    attr_accessor :options
+
+    # Creates a reader instance.
+    #
+    # @param [#each] iterator an iterator of tuples to render
+    # @param [Hash] options Reader's options (see doc of subclasses)
+    def initialize(input, options = {})
+      @input   = input
+      @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 delegates the call to {#render}.
+    def execute(output = $stdout)
+      each do |str|
+        output << str
+      end
+      output
+    end
+
+  private
+
+    def each_tuple(&bl)
+      return bl.call(input) if TupleLike===input
+      input.each(&bl)
+    end
+
+  end # class Renderer
+end # module Alf
+require_relative 'renderer/rash'
+require_relative 'renderer/text'
+require_relative 'renderer/yaml'
+require_relative 'renderer/json'
+require_relative 'renderer/csv'

data/lib/alf-io/alf/renderer/csv.rb

@@ -0,0 +1,30 @@
+module Alf
+  class Renderer
+    #
+    # Implements Alf::Renderer contract for outputting CSV files.
+    #
+    class CSV < Renderer
+      include Support::CSVUtils
+
+      def self.mime_type
+        "text/csv"
+      end
+
+      def each(&bl)
+        return to_enum unless block_given?
+        with_csv(ProcIO.new(bl), options.merge(row_sep: "\n")) do |csv|
+          header = nil
+          each_tuple do |tuple|
+            unless header
+              header = tuple.keys
+              csv << header.map(&:to_s)
+            end
+            csv << header.map{|k| tuple[k]}
+          end
+        end
+      end
+
+      Alf::Renderer.register(:csv, "in CSV", self)
+    end # class CSV
+  end # class Renderer
+end # module Alf

data/lib/alf-io/alf/renderer/json.rb

@@ -0,0 +1,33 @@
+module Alf
+  class Renderer
+    #
+    # Implements Alf::Renderer contract for outputing JSON.
+    #
+    class JSON < ::Alf::Renderer
+
+      def self.mime_type
+        "application/json"
+      end
+
+      def each
+        return to_enum unless block_given?
+        require 'json'
+        if TupleLike===input
+          yield ::JSON.dump(input.to_hash)
+          yield "\n"
+        else
+          i = 0
+          yield "["
+          input.each do |t|
+            yield ',' unless i==0
+            yield ::JSON.dump(t)
+            i += 1
+          end
+          yield "]\n"
+        end
+      end
+
+      Alf::Renderer.register(:json, "in JSON",  self)
+    end # class JSON
+  end # class Renderer
+end # module Alf

data/lib/alf-io/alf/renderer/rash.rb

@@ -0,0 +1,38 @@
+module Alf
+  class Renderer
+    #
+    # Implements the Renderer contract through inspect
+    #
+    class Rash < Renderer
+
+      def self.mime_type
+        nil
+      end
+
+      def each
+        return to_enum unless block_given?
+        if options[:pretty]
+          each_tuple do |tuple|
+            yield "{\n" << tuple.map{|k,v| "  #{l(k)} => #{l(v)}"}.join(",\n") << "\n}\n"
+          end
+        else
+          each_tuple do |tuple|
+            yield to_rash(tuple) << "\n"
+          end
+        end
+      end
+
+    private
+
+      def l(x)
+        Support.to_ruby_literal(x)
+      end
+
+      def to_rash(x)
+        l(x.is_a?(Tuple) ? x.to_hash : x)
+      end
+
+      Renderer.register(:rash, "as ruby hashes", self)
+    end # class Rash
+  end # class Renderer
+end # module Alf

data/lib/alf-io/alf/renderer/text.rb

@@ -0,0 +1,166 @@
+module Alf
+  class Renderer
+    class Text < Renderer
+
+      def self.mime_type
+        "text/plain"
+      end
+
+      module Utils
+
+        def max(x, y)
+          return y if x.nil?
+          return x if y.nil?
+          x > y ? x : y
+        end
+      end
+      include Utils
+
+      class Cell
+        include Utils
+
+        def initialize(value, options = {})
+          @value = value
+          @options = options
+        end
+
+        def min_width
+          @min_width ||= rendering_lines.inject(0) do |maxl,line|
+            max(maxl,line.size)
+          end
+        end
+
+        def rendering_lines(size = nil)
+          if size.nil?
+            text_rendering.split(/\n/)
+          elsif @value.is_a?(Numeric)
+            rendering_lines(nil).map{|l| "%#{size}s" % l}
+          else
+            rendering_lines(nil).map{|l| "%-#{size}s" % l}
+          end
+        end
+
+        def text_rendering
+          @text_rendering ||= case (value = @value)
+            when NilClass
+              "[nil]"
+            when Symbol
+              value.inspect
+            when Float
+              (@options[:float_format] || "%.3f") % value
+            when Hash
+              value.inspect
+            when RelationLike
+              Text.render(value, "", @options)
+            when Array
+              array_rendering(value)
+            when Time, DateTime
+              value.to_s
+            else
+              value.to_s
+          end
+        end
+
+        def array_rendering(value)
+          if TupleLike===value.first
+            Text.render(value, "")
+          elsif value.empty?
+            "[]"
+          else
+            values = value.map{|x| Cell.new(x).text_rendering}
+            if values.inject(0){|memo,s| memo + s.size} < 20
+              "[" + values.join(", ") + "]"
+            else
+              "[" + values.join(",\n ") + "]"
+            end
+          end
+        end
+
+      end # class Cell
+
+      class Row
+        include Utils
+
+        def initialize(values, options = {})
+          @cells = values.map{|v| Cell.new(v, options)}
+          @options = options
+        end
+
+        def min_widths
+          @cells.map{|cell| cell.min_width}
+        end
+
+        def rendering_lines(sizes = min_widths)
+          nb_lines = 0
+          by_cell = @cells.zip(sizes).map do |cell,size|
+            lines = cell.rendering_lines(size)
+            nb_lines = max(nb_lines, lines.size)
+            lines
+          end
+          grid = (0...nb_lines).map do |line_i|
+            "| " + by_cell.zip(sizes).map{|cell_lines, size|
+              cell_lines[line_i] || " "*size
+            }.join(" | ") + " |"
+          end
+          grid.empty? ? ["|  |"] : grid
+        end
+
+      end # class Row
+
+      class Table
+        include Utils
+
+        def initialize(records, attributes, options = {})
+          @header  = Row.new(attributes)
+          @rows    = records.map{|r| Row.new(r, options)}
+          @options = options
+        end
+        attr_reader :header, :rows, :options
+
+        def sizes
+          @sizes ||= rows.inject(header.min_widths) do |memo,row|
+            memo.zip(row.min_widths).map{|x,y| max(x,y)}
+          end
+        end
+
+        def sep
+          @sep ||= '+-' << sizes.map{|s| '-' * s}.join('-+-') << '-+' << "\n"
+        end
+
+        def each
+          return to_enum unless block_given?
+          yield(sep)
+          yield header.rendering_lines(sizes).first << "\n"
+          yield(sep)
+          rows.each do |row|
+            row.rendering_lines(sizes).each do |line|
+              yield(line << "\n")
+            end
+          end
+          yield(sep)
+        end
+
+        def to_s
+          each.each_with_object(""){|line,buf| buf << line}
+        end
+
+      end # class Table
+
+      def each(&bl)
+        input    = self.input
+        input    = [input.to_hash] if TupleLike===input
+        relation = input.to_a
+        attrs    = relation.inject([]){|memo,t| (memo | t.keys)}
+        records  = relation.map{|t| attrs.map{|a| t[a]}}
+        table    = Table.new(records, attrs, options)
+        table.each(&bl)
+      end
+
+      def self.render(input, output, options= {})
+        new(input, options).execute(output)
+      end
+
+      ::Alf::Renderer.register(:text, "as a text table",  self)
+    end # class Text
+  end # class Renderer
+end # module Alf

data/lib/alf-io/alf/renderer/yaml.rb

@@ -0,0 +1,25 @@
+module Alf
+  class Renderer
+    #
+    # Implements Alf::Renderer contract for outputing YAML files.
+    #
+    class YAML < ::Alf::Renderer
+
+      def self.mime_type
+        "text/x-yaml"
+      end
+
+      def each
+        return to_enum unless block_given?
+        require "yaml"
+        yield("---\n")
+        input.each do |tuple|
+          yield "-" << tuple.to_hash.to_yaml[4..-1].gsub(/^/, "  ")[1..-1]
+        end
+        yield("\n")
+      end
+
+      Alf::Renderer.register(:yaml, "in YAML",  self)
+    end # class YAML
+  end # class Renderer
+end # module Alf