alf 0.12.2 → 0.13.0

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

@@ -1,7 +0,0 @@
-module Alf
-  module Engine
-    module Semi
-    end # module Semi
-  end # module Engine
-end # module Alf
-require_relative 'semi/hash'

data/lib/alf-engine/alf/engine/semi/hash.rb

@@ -1,39 +0,0 @@
-module Alf
-  module Engine
-    #
-    # Filters tuples from `left` that match or do not match tuples from `right`.
-    #
-    class Semi::Hash < Cog
-
-      # @return [Enumerable] The left operand
-      attr_reader :left
-
-      # @return [Enumerable] The right operand
-      attr_reader :right
-
-      # @return [Boolean] Match (true) or not match (false)?
-      attr_reader :predicate
-
-      # Creates a Semi::Hash instance
-      def initialize(left, right, predicate)
-        @left = left
-        @right = right
-        @predicate = predicate
-      end
-
-      # (see Cog#each)
-      def each
-        index = nil
-        left.each do |left_tuple|
-          index ||= Materialize::Hash.new(right, lambda{|t|
-            AttrList.new(left_tuple.keys & t.keys)
-          }).prepare
-          if index[left_tuple, true].empty? != predicate
-            yield left_tuple 
-          end
-        end
-      end
-
-    end # class Semi::Hash
-  end # module Engine
-end # module Alf

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

@@ -1,46 +0,0 @@
-module Alf
-  module Engine
-    #
-    # Set computed tuples attributes. This cog allows implementing both
-    # EXTEND and UPDATE relational operators.
-    # 
-    # Example:
-    #
-    #     rel = [
-    #       {:name => "Jones", :city => "London"}
-    #     ]
-    #     comp = TupleComputation[
-    #       :city   => lambda{ city.upcase },
-    #       :concat => lambda{ "#{name} #{city}" }
-    #     ]
-    #     SetAttr.new(rel, comp).to_a
-    #     # => [
-    #     #      {:name => "Jones", :city => "LONDON", :concat => "Jones LONDON"}
-    #     #    ]
-    #
-    class SetAttr < Cog
-
-      # @return [Enumerable] The operand
-      attr_reader :operand
-
-      # @return [TupleComputation] Computed attributes as a computation
-      attr_reader :computation
-
-      # Creates a SetAttr instance
-      def initialize(operand, computation)
-        @operand = operand
-        @computation = computation
-      end
-
-      # (see Cog#each)
-      def each
-        handle = Tools::TupleHandle.new
-        operand.each do |tuple|
-          computed = @computation.evaluate(handle.set(tuple))
-          yield tuple.merge(computed){|k,v1,v2| v2}
-        end
-      end
-
-    end # class SetAttr
-  end # module Engine
-end # module Alf

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

@@ -1,28 +0,0 @@
-module Alf
-  module Engine
-    #
-    # Sort its operand according to an ordering information.
-    #
-    class Sort < Cog
-
-      # @return [Enumerable] The operand
-      attr_reader :operand
-
-      # @return [Ordering] The ordering info
-      attr_reader :ordering
-
-      # Creates an Autonum instance
-      def initialize(operand, ordering)
-        @operand = operand
-        @ordering = ordering
-      end
-
-      # (see Cog#each)
-      def each(&block)
-        Sort::InMemory.new(operand, ordering).each(&block)
-      end
-
-    end # class Sort
-  end # module Engine
-end # module Alf
-require_relative 'sort/in_memory'

data/lib/alf-engine/alf/engine/sort/in_memory.rb

@@ -1,39 +0,0 @@
-module Alf
-  module Engine
-    #
-    # Implement an in-memory sort, relying on `to_a.sort!`
-    #
-    # Example:
-    #
-    #     rel = [
-    #       {:name => "Smith"},
-    #       {:name => "Jones"}
-    #     ]
-    #     Sort.new(rel, Ordering[[:name, :asc]]).to_a
-    #     # => [
-    #     #      {:name => "Jones"}
-    #     #      {:name => "Smith"},
-    #     #    ]
-    #
-    class Sort::InMemory < Cog
-
-      # @return [Enumerable] The operand
-      attr_reader :operand
-
-      # @return [Ordering] The ordering info
-      attr_reader :ordering
-
-      # Creates an Autonum instance
-      def initialize(operand, ordering)
-        @operand = operand
-        @ordering = ordering
-      end
-
-      # (see Cog#each)
-      def each(&block)
-        operand.to_a.sort!(&ordering.sorter).each(&block)
-      end
-
-    end # class Sort::InMemory
-  end # module Engine
-end # module Alf

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

@@ -1,8 +0,0 @@
-module Alf
-  module Engine
-    module Summarize
-    end # module Summarize
-  end # module Engine
-end # module Alf
-require_relative 'summarize/cesure'
-require_relative 'summarize/hash'

data/lib/alf-engine/alf/engine/summarize/cesure.rb

@@ -1,51 +0,0 @@
-module Alf
-  module Engine
-    class Summarize::Cesure < Cog
-      include Engine::Cesure
-
-      # @return [Enumerable] The operand
-      attr_reader :operand
-
-      # @return [AttrList] Summarization key
-      attr_reader :by
-
-      # @return [Summarization] The summarization to use
-      attr_reader :summarization
-
-      # @return [Boolean] Make an allbut summarization?
-      attr_reader :allbut
-
-      # Creates an Aggregate instance
-      def initialize(operand, by, summarization, allbut)
-        @operand = operand
-        @by = by
-        @summarization = summarization
-        @allbut = allbut
-      end
-
-      protected
-
-      # (see Cesure#project)
-      def project(tuple)
-        @by.project_tuple(tuple, @allbut)
-      end
-      
-      # (see Cesure#start_cesure)
-      def start_cesure(key, receiver)
-        @aggs = @summarization.least
-      end
-
-      # (see Cesure#accumulate_cesure)
-      def accumulate_cesure(tuple, receiver)
-        @aggs = @summarization.happens(@aggs, tuple)
-      end
-
-      # (see Cesure#flush_cesure)
-      def flush_cesure(key, receiver)
-        @aggs = @summarization.finalize(@aggs)
-        receiver.call key.merge(@aggs)
-      end
-
-    end # class Summarize::Cesure
-  end # module Engine
-end # module Alf

data/lib/alf-engine/alf/engine/summarize/hash.rb

@@ -1,35 +0,0 @@
-module Alf
-  module Engine
-    class Summarize::Hash < Cog
-
-      # @return [Enumerable] The operand
-      attr_reader :operand
-
-      # @return [AttrList] Summarization key
-      attr_reader :by
-
-      # @return [Summarization] The summarization to use
-      attr_reader :summarization
-
-      # @return [Boolean] Make an allbut summarization?
-      attr_reader :allbut
-
-      # Creates an Aggregate instance
-      def initialize(operand, by, summarization, allbut)
-        @operand = operand
-        @by = by
-        @summarization = summarization
-        @allbut = allbut
-      end
-
-      # (see Cog#each)
-      def each
-        index = Materialize::Hash.new(operand, by, allbut)
-        index.each_pair do |k, v|
-          yield k.merge(summarization.summarize(v))
-        end
-      end
-
-    end # class Summarize::Cesure
-  end # module Engine
-end # module Alf

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

@@ -1,29 +0,0 @@
-module Alf
-  module Engine
-    class Ungroup < 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.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

@@ -1,31 +0,0 @@
-module Alf
-  module Engine
-    #
-    # Unwraps a tuple attribute
-    #
-    class Unwrap < 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.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

@@ -1,39 +0,0 @@
-module Alf
-  module Engine
-    #
-    # Wraps attributes under as a sub-tuple
-    #
-    class Wrap < 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-logs/alf/logs.rb

@@ -1 +0,0 @@
-require_relative 'logs/reader'

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

@@ -1,98 +0,0 @@
-module Alf
-  module Logs
-    #
-    # Implements Alf::Reader contract for reading log files.
-    #
-    class Reader < Alf::Reader
-
-      DEFAULT_OPTIONS = {
-        :file_format => nil,
-        :line_def    => :access
-      }
-
-      attr_reader :options
-
-      def initialize(*args)
-        Alf::Tools::friendly_require('request_log_analyzer')
-        super(*args)
-        @options[:file_format] = coerce_file_format(@options[:file_format])
-      end
-
-      def each
-        parser = infer_parser(input_path)
-        with_input_io do |io|
-          parser.parse_stream(io) do |req|
-            yield request_to_tuple(req)
-          end
-        end
-      end
-
-      private
-
-      def coerce_file_format(file_format)
-        case file_format
-        when NilClass
-          nil
-        when RequestLogAnalyzer::FileFormat
-          file_format
-        when Symbol
-          RequestLogAnalyzer::FileFormat.load(file_format)
-        when Array
-          RequestLogAnalyzer::FileFormat.load(*file_format)
-        else 
-          raise ArgumentError, "Invalid file format: #{file_format}"
-        end
-      end
-
-      def infer_parser(path)
-        file_format = @options[:file_format] || begin
-          unless path
-            raise NotImplementedError, "Logs::Reader does not work on IO for now"
-          end
-          RequestLogAnalyzer::FileFormat.autodetect(path)
-        end
-        RequestLogAnalyzer::Source::LogParser.new(file_format)
-      end
-
-      def request_to_tuple(req)
-        req.attributes
-      end
-
-      LOG_TYPES = {
-        # RequestLogAnalyzer::Request::Converters
-        :string          => String,
-        :float           => Float,
-        :decimal         => Float,
-        :int             => Integer,
-        :integer         => Integer,
-        :sym             => Symbol,
-        :symbol          => Symbol,
-        :timestamp       => Integer,
-        :traffic         => Integer,
-        :duration        => Float,
-        :epoch           => Integer,
-        # AmazonS3
-        :nillable_string => String,
-        :referer         => String,
-        :user_agent      => String,
-        # Apache
-        :path            => String,
-        # MySQL
-        :sql             => String
-      }
-
-      def infer_heading(format, line_def = :access)
-        h = Hash[format.line_definitions[line_def].captures.collect{|capt|
-          [ capt[:name], to_type(capt[:type]) ]
-        }]
-        Alf::Heading.new(h)
-      end
-
-      def to_type(log_type)
-        LOG_TYPES[log_type] || String
-      end
-
-      Alf::Reader.register(:logs, [".log"], self)
-    end # class Reader
-  end # module Logs
-end # module Alf