bmg 0.17.5 → 0.17.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: faea9567e3ec11347ccd8d1e063d027a720095bc8623221597a40e26aade3d99
-  data.tar.gz: 01b649d2810c6460822c06c83ce06911d438f68cc9b8d297afb766c389619544
+  metadata.gz: e67d11656619195bfaa20a9d55fff49d593ccaa3ad558d0876c82534977d4e04
+  data.tar.gz: 7ecd9b926d4289feb0fec3efcafcf7b14c483b70f8c4e47b87e3ba038db64774
 SHA512:
-  metadata.gz: e75f1778fc7fd0578b37fda44c6b2ccf5f5aa4441c16efeb42b495c38bc9361495b6597d70ce0ea8829caceaceb708c247c24b8531464d6c16f8f3faef1ee01f
-  data.tar.gz: 3762248213c27bf9e11276fe3a2b9deb75a124e80cc2f7cdf8fbe9a70856649f85fe55eb71474ae6f4a2836fd3d2d144ff6ae44b7b3810ff08bde51d813136a1
+  metadata.gz: 4d99c96391c73c096e3e981155cbe53e637c909854a0e3fe92bae991eb7da1be7cf78188c87f9fb53cdbb90e5dd0d92b4fec0501f8d1fcf7f1cdb1900828d575
+  data.tar.gz: f8ff33a830852b1e0c5648596ef5f11cae7fc5f7bd817c1ed30a73ce3da81a92bfb42871eecd928a3ce7b717499fb9a975ee8f174a1b013054af506ed056b825

data/README.md

@@ -132,6 +132,10 @@ r.restrict(a: "foo", b: "bar", ...)          # relational restriction, aka where
 r.rxmatch([:a, :b, ...], /xxx/)              # regex match kind of restriction
 r.summarize([:a, :b, ...], x: :sum)          # relational summarization
 r.suffix(:_foo, but: [:a, ...])              # suffix kind of renaming
+t.transform(:to_s)                           # all-attrs transformation
+t.transform(&:to_s)                          # similar, but Proc-driven
+t.transform(:foo => :upcase, ...)            # specific-attrs tranformation
+t.transform([:to_s, :upcase])                # chain-transformation
 r.union(right)                               # relational union
 ```
 

data/lib/bmg.rb

@@ -44,6 +44,7 @@ module Bmg
   require_relative 'bmg/relation/in_memory'
   require_relative 'bmg/relation/spied'
   require_relative 'bmg/relation/materialized'
+  require_relative 'bmg/relation/proxy'
 
   # Deprecated
   Leaf = Relation::InMemory

data/lib/bmg/algebra.rb

@@ -172,6 +172,16 @@ module Bmg
     end
     protected :_summarize
 
+    def transform(transformation = nil, options = {}, &proc)
+      transformation, options = proc, (transformation || {}) unless proc.nil?
+      _transform(self.type.transform(transformation, options), transformation, options)
+    end
+
+    def _transform(type, transformation, options)
+      Operator::Transform.new(type, self, transformation, options)
+    end
+    protected :_transform
+
     def union(other, options = {})
       return self if other.is_a?(Relation::Empty)
       _union self.type.union(other.type), other, options

data/lib/bmg/operator.rb

@@ -46,4 +46,5 @@ require_relative 'operator/rename'
 require_relative 'operator/restrict'
 require_relative 'operator/rxmatch'
 require_relative 'operator/summarize'
+require_relative 'operator/transform'
 require_relative 'operator/union'

data/lib/bmg/operator/transform.rb

@@ -0,0 +1,57 @@
+module Bmg
+  module Operator
+    #
+    # Transform operator.
+    #
+    # Transforms existing attributes through computations
+    #
+    # Example:
+    #
+    #   [{ a: 1 }] transform { a: ->(t){ t[:a]*2 } } => [{ a: 4 }]
+    #
+    class Transform
+      include Operator::Unary
+
+      DEFAULT_OPTIONS = {}
+
+      def initialize(type, operand, transformation, options = {})
+        @type = type
+        @operand = operand
+        @transformation = transformation
+        @options = DEFAULT_OPTIONS.merge(options)
+      end
+
+    protected
+
+      attr_reader :transformation
+
+    public
+
+      def each
+        t = transformer
+        @operand.each do |tuple|
+          yield t.call(tuple)
+        end
+      end
+
+      def to_ast
+        [ :transform, operand.to_ast, transformation.dup ]
+      end
+
+    protected ### optimization
+
+    protected ### inspect
+
+      def args
+        [ transformation ]
+      end
+
+    private
+
+      def transformer
+        @transformer ||= TupleTransformer.new(transformation)
+      end
+
+    end # class Transform
+  end # module Operator
+end # module Bmg

data/lib/bmg/relation/proxy.rb

@@ -0,0 +1,63 @@
+module Bmg
+  module Relation
+    #
+    # This module can be used to create typed collection on top
+    # of Bmg relations. Algebra methods will be delegated to the
+    # decorated relation, and results wrapped in a new instance
+    # of the class.
+    #
+    module Proxy
+
+      def initialize(relation)
+        @relation = relation
+      end
+
+      def method_missing(name, *args, &bl)
+        if @relation.respond_to?(name)
+          res = @relation.send(name, *args, &bl)
+          res.is_a?(Relation) ? _proxy(res) : res
+        else
+          super
+        end
+      end
+
+      def respond_to?(name, *args)
+        @relation.respond_to?(name) || super
+      end
+
+      [
+        :extend
+      ].each do |name|
+        define_method(name) do |*args, &bl|
+          res = @relation.send(name, *args, &bl)
+          res.is_a?(Relation) ? _proxy(res) : res
+        end
+      end
+
+      [
+        :one,
+        :one_or_nil
+      ].each do |meth|
+        define_method(meth) do |*args, &bl|
+          res = @relation.send(meth, *args, &bl)
+          res.nil? ? nil : _proxy_tuple(res)
+        end
+      end
+
+      def to_json(*args, &bl)
+        @relation.to_json(*args, &bl)
+      end
+
+    protected
+
+      def _proxy(relation)
+        self.class.new(relation)
+      end
+
+      def _proxy_tuple(tuple)
+        tuple
+      end
+
+    end # module Proxy
+  end # class Relation
+end # module Bmg

data/lib/bmg/support.rb

@@ -1,2 +1,3 @@
 require_relative 'support/tuple_algebra'
+require_relative 'support/tuple_transformer'
 require_relative 'support/keys'

data/lib/bmg/support/keys.rb

@@ -7,6 +7,10 @@ module Bmg
 
   public ## tools
 
+    def select(&bl)
+      Keys.new(@keys.select(&bl), false)
+    end
+
   public ## algebra
 
     def allbut(oldtype, newtype, butlist)

data/lib/bmg/support/tuple_transformer.rb

@@ -0,0 +1,62 @@
+module Bmg
+  class TupleTransformer
+
+    def initialize(transformation)
+      @transformation = transformation
+    end
+
+    def self.new(arg)
+      return arg if arg.is_a?(TupleTransformer)
+      super
+    end
+
+    def call(tuple)
+      transform_tuple(tuple, @transformation)
+    end
+
+    def knows_attrlist?
+      @transformation.is_a?(Hash)
+    end
+
+    def to_attrlist
+      @transformation.keys
+    end
+
+    private
+
+      def transform_tuple(tuple, with)
+        case with
+        when Symbol
+          tuple.each_with_object({}){|(k,v),dup|
+            dup[k] = transform_attr(v, with)
+          }
+        when Proc
+          tuple.each_with_object({}){|(k,v),dup|
+            dup[k] = transform_attr(v, with)
+          }
+        when Hash
+          with.each_with_object(tuple.dup){|(k,v),dup|
+            dup[k] = transform_attr(dup[k], v)
+          }
+        when Array
+          with.inject(tuple){|dup,on|
+            transform_tuple(dup, on)
+          }
+        else
+          raise ArgumentError, "Unexpected transformation `#{with.inspect}`"
+        end
+      end
+
+      def transform_attr(value, with)
+        case with
+        when Symbol
+          value.send(with)
+        when Proc
+          with.call(value)
+        else
+          raise ArgumentError, "Unexpected transformation `#{with.inspect}`"
+        end
+      end
+
+  end # module TupleTransformer
+end # module Bmg

data/lib/bmg/type.rb

@@ -241,6 +241,31 @@ module Bmg
       }
     end
 
+    def transform(transformation, options = {})
+      transformer = TupleTransformer.new(transformation)
+      if typechecked? && knows_attrlist? && transformer.knows_attrlist?
+        known_attributes!(transformer.to_attrlist)
+      end
+      keys = if options[:key_preserving]
+        self._keys
+      elsif transformer.knows_attrlist? && knows_keys?
+        touched_attrs = transformer.to_attrlist
+        keys = self._keys.select{|k| (k & touched_attrs).empty? }
+      else
+        nil
+      end
+      pred = if transformer.knows_attrlist?
+        attr_list = transformer.to_attrlist
+        predicate.and_split(attr_list).last
+      else
+        Predicate.tautology
+      end
+      dup.tap{|x|
+        x.keys = keys
+        x.predicate = pred
+      }
+    end
+
     def union(other)
       if typechecked? && knows_attrlist? && other.knows_attrlist?
         missing = self.attrlist - other.attrlist

data/lib/bmg/version.rb

@@ -2,7 +2,7 @@ module Bmg
   module Version
     MAJOR = 0
     MINOR = 17
-    TINY  = 5
+    TINY  = 6
   end
   VERSION = "#{Version::MAJOR}.#{Version::MINOR}.#{Version::TINY}"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bmg
 version: !ruby/object:Gem::Version
-  version: 0.17.5
+  version: 0.17.6
 platform: ruby
 authors:
 - Bernard Lambeau
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-08-17 00:00:00.000000000 Z
+date: 2020-08-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: predicate
@@ -149,6 +149,7 @@ files:
 - lib/bmg/operator/shared/nary.rb
 - lib/bmg/operator/shared/unary.rb
 - lib/bmg/operator/summarize.rb
+- lib/bmg/operator/transform.rb
 - lib/bmg/operator/union.rb
 - lib/bmg/reader.rb
 - lib/bmg/reader/csv.rb
@@ -157,6 +158,7 @@ files:
 - lib/bmg/relation/empty.rb
 - lib/bmg/relation/in_memory.rb
 - lib/bmg/relation/materialized.rb
+- lib/bmg/relation/proxy.rb
 - lib/bmg/relation/spied.rb
 - lib/bmg/sequel.rb
 - lib/bmg/sequel/ext.rb
@@ -259,6 +261,7 @@ files:
 - lib/bmg/support.rb
 - lib/bmg/support/keys.rb
 - lib/bmg/support/tuple_algebra.rb
+- lib/bmg/support/tuple_transformer.rb
 - lib/bmg/type.rb
 - lib/bmg/version.rb
 - lib/bmg/writer.rb