alf 0.12.2 → 0.13.0

data/lib/alf/renderer/rash.rb

@@ -1,33 +0,0 @@
-module Alf
-  class Renderer
-    #
-    # Implements the Renderer contract through inspect
-    #
-    class Rash < Renderer
-  
-      # (see Renderer#render)
-      def render(input, output)
-        if options[:pretty]
-          input.each do |tuple|
-            output << "{\n" << tuple.collect{|k,v| 
-              "  #{lit(k)} => #{lit(v)}" 
-            }.join(",\n") << "\n}\n"
-          end
-        else
-          input.each do |tuple|
-            output << lit(tuple) << "\n"
-          end
-        end
-        output
-      end
-
-      private 
-
-      def lit(x)
-        Tools.to_ruby_literal(x)
-      end
-  
-      Renderer.register(:rash, "as ruby hashes", self)
-    end # class Rash
-  end # class Renderer
-end # module Alf

data/lib/alf/renderer/text.rb

@@ -1,198 +0,0 @@
-module Alf
-  module Text
-
-    #
-    # Implements Alf::Renderer for outputting beautiful text tables.
-    #
-    class Renderer < ::Alf::Renderer
-  
-      module Utils
-  
-        def looks_a_relation?(value)
-          value.is_a?(Alf::Iterator) or
-            (value.is_a?(Array) && !value.empty? && value.all?{|v| v.is_a?(Hash)})
-        end
-  
-        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).collect{|l| "%#{size}s" % l}
-          else
-            rendering_lines(nil).collect{|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 Alf::Iterator
-              Text::Renderer.render(value, "", @options)
-            when Array
-              array_rendering(value)
-            else
-              value.to_s
-          end
-        end
-        
-        def array_rendering(value)
-          if looks_a_relation?(value) 
-            Text.render(value, "")
-          elsif value.empty?
-            "[]"
-          else
-            values = value.collect{|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.collect{|v| Cell.new(v, options)}
-          @options = options
-        end
-  
-        def min_widths
-          @cells.collect{|cell| cell.min_width}
-        end
-  
-        def rendering_lines(sizes = min_widths)
-          nb_lines = 0
-          by_cell = @cells.zip(sizes).collect do |cell,size|
-            lines = cell.rendering_lines(size)
-            nb_lines = max(nb_lines, lines.size)
-            lines
-          end
-          grid = (0...nb_lines).collect do |line_i|
-            "| " + by_cell.zip(sizes).collect{|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.collect{|r| Row.new(r, options)}
-          @options = options
-        end
-  
-        def render(buffer = "")
-          sizes = @rows.inject(@header.min_widths) do |memo,row|
-            memo.zip(row.min_widths).collect{|x,y| max(x,y)}
-          end
-          sep = '+-' << sizes.collect{|s| '-' * s}.join('-+-') << '-+'
-          buffer << sep << "\n"
-          buffer << @header.rendering_lines(sizes).first << "\n"
-          buffer << sep << "\n"
-          @rows.each do |row|
-            row.rendering_lines(sizes).each do |line|
-              buffer << line << "\n"
-            end
-          end
-          buffer << sep << "\n"
-          buffer
-        end
-  
-      end # class Table
-  
-      class PrettyBuffer 
-        
-        def initialize(out, options)
-          @out = out
-          @trim_at = options[:trim_at]
-          @page_at = options[:page_at]
-          @page_line = 0
-        end
-
-        def <<(str)
-          print_a_line trim(str)
-          self
-        end
-
-        def trim(str)
-          return str unless (@trim_at && (str.length > @trim_at))
-          trimmed = (str[0..(@trim_at-4)] + "...")
-          trimmed << "\n" if str =~ /\n$/
-          trimmed
-        end
-
-        def print_a_line(line)
-          @out << line
-          @page_line += 1
-          do_wait if @page_at && (@page_line > @page_at)
-        end
-
-        def do_wait
-          @out << "--- Press ENTER (or quit) ---\n"
-          throw :stop if $stdin.getc =~ /^[qQ](uit)?/
-          @page_line = 0
-        end
-
-      end # class PrettyBuffer
-
-      protected
-      
-      def render(input, output)
-        relation = input.to_a
-        attrs    = relation.inject([]){|memo,t| (memo | t.keys)}
-        records  = relation.collect{|t| attrs.collect{|a| t[a]}}
-        table    = Table.new(records, attrs, options)
-        buffer   = options[:pretty] ? 
-                   PrettyBuffer.new(output, options) : output
-        catch(:stop){ table.render(buffer) }
-        output
-      end
-      
-      def self.render(input, output, options= {})
-        new(input, options).execute(output)
-      end
-      
-      ::Alf::Renderer.register(:text, "as a text table",  self)
-    end # class Renderer
-    
-  end # module Text
-end # module Alf

data/lib/alf/tools.rb

@@ -1,15 +0,0 @@
-module Alf
-  #
-  # Provides tooling methods that are used here and there in Alf.
-  # 
-  module Tools
-    require 'alf/tools/coerce'
-    require 'alf/tools/to_ruby_literal'
-    require 'alf/tools/to_lispy'
-    require 'alf/tools/to_relation'
-    require 'alf/tools/tuple_handle'
-    require 'alf/tools/miscellaneous'
-
-    extend Tools
-  end # module Tools
-end # module Alf

data/lib/alf/tools/coerce.rb

@@ -1,25 +0,0 @@
-module Alf
-  module Tools
-
-    # Defines all coercion rules, through Myrrha inheritance
-    Coercions = Myrrha::Coerce.dup.append do
-    end
-
-    # Coerces a value to a particular domain.
-    #
-    # Example:
-    #
-    #   Tools.coerce("123", Integer) # => 123
-    #
-    # @param [Object] val any value
-    # @param [Class] domain a domain, represented by a ruby class
-    # @return [Object] an instance of `domain` resulting from the coercion
-    # @raise [Myrrha::CoercionError] if something goes wrong
-    def coerce(val, domain)
-      Coercions.apply(val, domain)
-    rescue Myrrha::Error => ex
-      raise CoercionError, ex.message, caller
-    end
-
-  end # module Tools
-end # module Alf

data/lib/alf/tools/miscellaneous.rb

@@ -1,111 +0,0 @@
-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"]
-    #
-    # @param [Array] args some arguments passed to a method
-    # @param [Array<===>] some expected types
-    # @return [Array] an array with one value for each type
-    def varargs(args, types)
-      types.map{|t| t===args.first ? args.shift : nil}
-    end
-
-    # Attempts to require `who` the most friendly way as possible.
-    #
-    # This method allows loading weak dependencies in a friendly way. It takes
-    # care of ensuring the dependency requirement `req` through rubygems. The
-    # latter is loaded if required.
-    #
-    # Example:
-    #
-    #     Tools.friendly_require('sequel', '~> 3.0')
-    #
-    # @param [String] who the name of a gem
-    # @param [String] req optional requirements on the gem version
-    # @param [Boolean] retried (private parameter)
-    def friendly_require(who, req = nil, retried = false)
-      gem(who, req) if req && 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, req, true)
-      end
-    end
-
-    # Returns the unqualified name of a ruby class or module.
-    #
-    # Example
-    #
-    #   class_name(Alf::Tools) -> :Tools
-    #
-    # @param [Class] clazz a ruby class
-    # @return [Symbol] the unqualified name of the class as a Symbol
-    def class_name(clazz)
-      /([A-Za-z0-9_]+)$/.match(clazz.name.to_s)[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"
-    #
-    # @param [String or Symbol] a class or module name
-    # @return [String] the class or module name in ruby_case
-    def ruby_case(s)
-      s.to_s.gsub(/[A-Z]/){|x| "_#{x.downcase}"}[1..-1]
-    end
-
-    # Returns the first non nil values from arguments.
-    #
-    # When no non-nil value can be found, the block is yield if present. 
-    # Otherwise, nil is returned.
-    #
-    # Example:
-    #
-    #   coalesce(nil, 1, "abc")         # -> 1
-    #   coalesce(nil, nil){ "hello" }   # -> "hello"
-    #   coalesce(nil, nil)              # -> nil
-    #
-    # @param [Array] args a list of values
-    # @return [Object] the first non-nil value in `args`; the result of the 
-    #         block or nil if no non-nil value can be found.
-    def coalesce(*args)
-      if found = args.find{|x| !x.nil?}
-        found
-      elsif block_given?
-        yield
-      end
-    end
-
-    # Builds a tuple through enumeration.
-    # 
-    # Iterates over enum and yields the block on each element. Collect block 
-    # results as key/value pairs returns them as a Hash.
-    #
-    # @param [Enumerable] enum any enumerable
-    # @return [Tuple] a tuple built from yield results
-    def tuple_collect(enum)
-      Hash[enum.map{|elm| yield(elm)}]
-    end
-
-    # Infers the heading from a tuple
-    #
-    # @param [Tuple] tuple a tuple, represented by a Hash
-    # @param [Heading] the heading of the tuple
-    def tuple_heading(tuple)
-      Heading[Hash[tuple.map{|k,v| [k, v.class]}]]
-    end
-
-  end # module Tools
-end # module Alf

data/lib/alf/tools/to_lispy.rb

@@ -1,96 +0,0 @@
-module Alf
-  module Tools
-
-    # Converts `value` to a lispy expression.
-    #
-    # Example:
-    #
-    #     expr = Alf.lispy.compile{ 
-    #       (project :suppliers, [:name])
-    #     }
-    #     Tools.to_lispy(expr)
-    #     # => (project :suppliers, [:name])
-    #
-    # @param [Object] expr any ruby object denoting a lispy expression
-    # @return [String] a lispy expression for `value`
-    def to_lispy(expr)
-      ToLispy.apply(expr)
-    end
-
-    # 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
-
-      # AttrList -> [:sid, :sname, ...]
-      r.upon(Types::AttrList) do |v, rd|
-        Tools.to_ruby_literal(v.attributes)
-      end
-
-      # Heading -> {:sid => String, ...}
-      r.upon(Types::Heading) do |v, rd|
-        Tools.to_ruby_literal(v.to_h)
-      end
-
-      # Ordering -> [[:sid, :asc], ...]
-      r.upon(Types::Ordering) do |v, rd|
-        Tools.to_ruby_literal(v.ordering)
-      end
-
-      # Renaming -> {:old => :new, ...}
-      r.upon(Types::Renaming) do |v, rd|
-        Tools.to_ruby_literal(v.renaming)
-      end
-
-      # Iterator::Proxy -> :suppliers
-      r.upon(lambda{|v,rd| Iterator::Proxy === v}) do |v, rd|
-        Tools.to_ruby_literal(v.name)
-      end
-
-      # TupleExpression -> ->{ ... }
-      r.upon(Types::TupleExpression) do |v, rd|
-        "->{ #{v.has_source_code!} }"
-      end
-
-      # TupleComputation -> { :big => ->{ ... }, ... }
-      r.upon(Types::TupleComputation) do |v, rd|
-        "{" + v.computation.map{|name,compu|
-          [name.inspect, r.coerce(compu)].join(" => ")
-        }.join(', ') + "}"
-      end
-
-      # Aggregator -> agg.source
-      r.upon(lambda{|v,_| Aggregator === v}) do |v, rd|
-        v.has_source_code!
-      end
-
-      # Summarization -> { :total => ->{ ... } }
-      r.upon(Types::Summarization) do |v, rd|
-        "{" + v.aggregations.map{|name,compu|
-          [name.inspect, r.coerce(compu)].join(" => ")
-        }.join(', ') + "}"
-      end
-
-      # Command and Operator -> (operator operands, args, options)
-      cmd = lambda{|v,_| (Command === v) || (Operator === v)}
-      r.upon(cmd) do |v,rd|
-        cmdname  = v.class.rubycase_name
-        oper, args, opts = v.class.signature.collect_on(v)
-        args = opts.empty? ? (oper + args) : (oper + args + [ opts ])
-        args = args.map{|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 # ToLispy
-
-  end # module Tools
-end # module Alf