alf-core 0.13.0

data/lib/alf-engine/alf/engine/to_dot.rb

@@ -0,0 +1,60 @@
+module Alf
+  module Engine
+    class ToDot
+      include Alf::Support::DotUtils
+
+      def call(cog, buf = "")
+        buf << "/* #{cog} */\n"
+        buf << "digraph \"Alf\" {\n"
+        buf << "node [width=0.375,height=0.25,shape=record];\n"
+        apply(cog, buf)
+        buf << "}\n"
+        buf
+      end
+
+      def on_unary_operator(cog, buf, label)
+        buf << "#{cog.object_id} [label=#{dot_label(label)}];\n"
+        apply(cog.operand, buf)
+        buf << "#{cog.object_id} -> #{cog.operand.object_id} [label=\"operand\"];\n"
+      end
+
+      def on_binary_operator(cog, buf, label)
+        buf << "#{cog.object_id} [label=#{dot_label(label)}];\n"
+        apply(cog.left, buf)
+        apply(cog.right, buf)
+        buf << "#{cog.object_id} -> #{cog.left.object_id} [label=\"left\"];\n"
+        buf << "#{cog.object_id} -> #{cog.right.object_id} [label=\"right\"];\n"
+      end
+
+      def on_nary_operator(cog, buf, label)
+        buf << "#{cog.object_id} [label=#{dot_label(label)}];\n"
+        cog.operands.each_with_index do |op, i|
+          apply(op, buf)
+          buf << "#{cog.object_id} -> #{op.object_id} [label=#{dot_label(i)}];\n"
+        end
+      end
+
+      def on_leaf_operand(cog, buf = "")
+        case cog
+        when Relation
+          buf << "#{cog.object_id} [label=\"Relation\"];\n"
+        else
+          buf << "#{cog.object_id} [label=#{dot_label(cog)}];\n"
+        end
+      end
+
+      def apply(cog, buf)
+        if cog.respond_to?(:operand)
+          on_unary_operator(cog, buf, cog.class.name)
+        elsif cog.respond_to?(:left)
+          on_binary_operator(cog, buf, cog.class.name)
+        elsif cog.respond_to?(:operands)
+          on_nary_operator(cog, buf, cog.class.name)
+        else
+          on_leaf_operand(cog, buf)
+        end
+      end
+
+    end # class ToDot
+  end # module Engine
+end # module Alf

data/lib/alf-engine/alf/engine/type_safe.rb

@@ -0,0 +1,28 @@
+module Alf
+  module Engine
+    class TypeSafe
+      include Cog
+
+      # @return [Enumerable] The operand
+      attr_reader :operand
+
+      # @return [TypeChecker] Type checker to use
+      attr_reader :checker
+
+      # Creates an Coerce instance
+      def initialize(operand, checker)
+        @operand = operand
+        @checker = checker
+      end
+
+      # (see Cog#each)
+      def _each
+        @operand.each do |tuple|
+          raise TypeCheckError, "Invalid tuple `#{tuple.inspect}`" unless checker===tuple
+          yield(tuple)
+        end
+      end
+
+    end # class TypeSafe
+  end # module Engine
+end # module Alf

data/lib/alf-engine/alf/engine/ungroup.rb

@@ -0,0 +1,31 @@
+module Alf
+  module Engine
+    class Ungroup
+      include Cog
+
+      # @return [Enumerable] The operand
+      attr_reader :operand
+
+      # @return [AttrName] Relation-valued attribute to ungroup
+      attr_reader :attribute
+
+      # Creates a Ungroup instance
+      def initialize(operand, attribute)
+        @operand = operand
+        @attribute = attribute
+      end
+
+      # (see Cog#each)
+      def _each
+        operand.each do |tuple|
+          tuple = tuple.dup
+          tuple = tuple.to_hash unless tuple.is_a?(Hash)
+          tuple.delete(@attribute).each do |subtuple|
+            yield tuple.merge(subtuple)
+          end
+        end
+      end
+
+    end # class Ungroup
+  end # module Engine
+end # module Alf

data/lib/alf-engine/alf/engine/unwrap.rb

@@ -0,0 +1,33 @@
+module Alf
+  module Engine
+    #
+    # Unwraps a tuple attribute
+    #
+    class Unwrap
+      include Cog
+
+      # @return [Enumerable] The operand
+      attr_reader :operand
+
+      # @return [AttrName] Name of the attribute to unwrap
+      attr_reader :attribute
+
+      # Creates a SetAttr instance
+      def initialize(operand, attribute)
+        @operand = operand
+        @attribute = attribute
+      end
+
+      # (see Cog#each)
+      def _each
+        operand.each do |tuple|
+          tuple = tuple.dup
+          tuple = tuple.to_hash unless tuple.is_a?(Hash)
+          tuple.merge!(tuple.delete(@attribute) || {})
+          yield tuple
+        end
+      end
+
+    end # class Unwrap
+  end # module Engine
+end # module Alf

data/lib/alf-engine/alf/engine/wrap.rb

@@ -0,0 +1,40 @@
+module Alf
+  module Engine
+    #
+    # Wraps attributes under as a sub-tuple
+    #
+    class Wrap
+      include Cog
+
+      # @return [Enumerable] The operand
+      attr_reader :operand
+
+      # @return [AttrList] Attributes to wrap
+      attr_reader :attributes
+
+      # @return [AttrName] Name of the introduced wrapped attribute
+      attr_reader :as
+
+      # @return [Boolean] Allbut wrapping?
+      attr_reader :allbut
+
+      # Creates a SetAttr instance
+      def initialize(operand, attributes, as, allbut)
+        @operand = operand
+        @attributes = attributes
+        @as = as
+        @allbut = allbut
+      end
+
+      # (see Cog#each)
+      def _each
+        operand.each do |tuple|
+          rest, key = @attributes.split_tuple(tuple, @allbut)
+          key[@as] = rest
+          yield key
+        end
+      end
+
+    end # class Wrap
+  end # module Engine
+end # module Alf

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

@@ -0,0 +1,6 @@
+require_relative 'support/csv_utils'
+require_relative 'reader'
+require_relative 'renderer'
+module Alf
+  class UnsupportedMimeTypeError < Error; end
+end

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

@@ -0,0 +1,189 @@
+module Alf
+  #
+  # Implements an iterator at the interface with the outside world.
+  #
+  # This base class provides a default behavior for readers that works with IO objects. It
+  # can be safely extended, overriden, or mimiced. This class also provides a registration
+  # mechanism to help getting Reader instances for specific file extensions. A typical
+  # scenario for using this registration mechanism is as follows:
+  #
+  #   # Registers a reader kind named :foo, associated with ".foo" file
+  #   # extensions and the FooFileDecoder class (typically a subclass of
+  #   # Reader)
+  #   Reader.register(:foo, [".foo"], FooFileDecoder)
+  #
+  #   # Later on, you can request a reader instance for a .foo file
+  #   r = Reader.reader('/a/path/to/a/file.foo')
+  #
+  #   # Also, a factory method is automatically installed on the Reader class
+  #   # itself. This factory method can be used with a String, or an IO object.
+  #   r = Reader.foo([a path or a IO object])
+  #
+  class Reader
+    include Alf::Engine::Cog
+    include Enumerable
+
+    class << self
+      include Support::Registry
+
+      # Registers a reader class associated with specific file extensions.
+      #
+      # Registered class must provide a constructor with the following signature
+      # `new(path_or_io, connection = nil, options = {})`. The registration name must be a
+      # symbol which can safely be used as a ruby method name. A factory method of that
+      # name and signature is automatically installed on the Reader class.
+      #
+      # @param [Symbol] name a name for the kind of data decoded
+      # @param [Array] extensions file extensions mapped to the registered reader
+      #                class (should include the '.', e.g. '.foo')
+      # @param [Class] class Reader subclass used to decode this kind of files
+      def register(name, extensions, clazz)
+        super([name, extensions, clazz], Reader)
+      end
+
+      # Returns a Reader on `source` denoting a physical representation of a relation.
+      #
+      # @param [...]     source a String, a Path or an IO denoting a relation physical source.
+      # @param [Array]   args optional reader arguments
+      # @return [Reader] a reader instance built from arguments
+      # @raise [ArgumentError] if `source` is not recognized or no reader can be found.
+      #
+      def reader(source, *args)
+        if Path.like?(source)
+          has_reader_for_ext!(Path(source).extname).new(source, *args)
+        elsif args.empty?
+          coerce(source)
+        else
+          raise ArgumentError, "Unable to return a reader for `#{source}`"
+        end
+      end
+
+      # Coerces `arg` to a Reader instance.
+      #
+      # @param [Object] arg any value coercable to a Reader instance
+      def coerce(arg)
+        case arg
+        when Reader       then arg
+        when IO, StringIO then rash(arg)
+        else
+          raise ArgumentError, "Unable to coerce `#{arg}` to a reader"
+        end
+      end
+
+      # Returns a Reader instance for the given mime type.
+      #
+      # @param [String] mime_type a given (simplified) MIME type
+      # @param [...] args other arguments to pass to the reader 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 reader for `#{mime_type}`"
+        end
+      end
+
+    private
+
+      # @return [Class] the reader class to use for `ext` file extension.
+      # @raise [ArgumentError] if no such reader class can be found
+      def has_reader_for_ext!(ext)
+        entry = registered.find{|r| r[1].include?(ext)}
+        return entry[2] if entry
+        raise ArgumentError, "No registered reader for `#{ext}`"
+      end
+
+    end # class << self
+
+    # Default reader options
+    DEFAULT_OPTIONS = {}
+
+    # @return [String, IO, ...] Input as initially provided to initialize
+    attr_accessor :input
+
+    # @returns [Path] a Path instance if input can be localized
+    attr_reader :path
+
+    # @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 [Hash] options Reader's options (see doc of subclasses)
+    def initialize(input, options = {})
+      @input   = input
+      @path    = Path(@input)
+      @options = self.class.const_get(:DEFAULT_OPTIONS).merge(options)
+    end
+
+    # Yields each tuple in turn
+    #
+    # @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
+      return to_enum unless block_given?
+      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
+      path && path.to_s
+    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(&bl)
+      case input
+      when IO, StringIO
+        input.rewind unless input.pos==0
+        yield input
+      when String, Path
+        Path(input).open('r', &bl)
+      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 # class Reader
+end # module Alf
+require_relative 'reader/rash'
+require_relative 'reader/csv'
+require_relative 'reader/json'

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

@@ -0,0 +1,28 @@
+module Alf
+  class Reader
+    #
+    # Implements Alf::Reader contract for reading CSV files.
+    #
+    class CSV < Reader
+      include Support::CSVUtils
+
+      def self.mime_type
+        "text/csv"
+      end
+
+      def each
+        return to_enum unless block_given?
+        with_input_io do |io|
+          block = Proc.new{|row|
+            next if row.header_row?
+            yield(::Alf::Support.symbolize_keys(row.to_hash))
+          }
+          csv_input = io.is_a?(StringIO) ? io.string : io
+          get_csv(csv_input, options).each(&block)
+        end
+      end
+
+      Alf::Reader.register(:csv, [".csv"], self)
+    end # class CSV
+  end # class Reader
+end # module Alf

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

@@ -0,0 +1,25 @@
+module Alf
+  class Reader
+    #
+    # Implements Alf::Reader contract for reading JSON input.
+    #
+    class JSON < Reader
+
+      def self.mime_type
+        "application/json"
+      end
+
+      def each
+        return to_enum unless block_given?
+        require 'json'
+        p = ::JSON.parse(input_text, create_additions: false)
+        p = [p] if TupleLike===p
+        p.each do |t|
+          yield Support.symbolize_keys(t)
+        end
+      end
+
+      Alf::Reader.register(:json, [".json"], self)
+    end # class JSON
+  end # class Reader
+end # module Alf