faceter 0.0.1

data/lib/faceter/nodes/fold.rb

@@ -0,0 +1,25 @@
+module Faceter
+
+  module Nodes
+
+    # The node describes exclusion of the field from a tuple
+    #
+    # @api private
+    #
+    class Fold < AbstractMapper::Node
+
+      attribute :key
+
+      # Transformer function, defined by the node
+      #
+      # @return [Transproc::Function]
+      #
+      def transproc
+        Functions[-> value { { key => value } }]
+      end
+
+    end # class Fold
+
+  end # module Nodes
+
+end # module Faceter

data/lib/faceter/nodes/group.rb

@@ -0,0 +1,26 @@
+module Faceter
+
+  module Nodes
+
+    # The node describes grouping fields from tuples into nested arrays
+    #
+    # @api private
+    #
+    class Group < AbstractMapper::Node
+
+      attribute :key
+      attribute :selector
+
+      # Transformer function, defined by the node
+      #
+      # @return [Transproc::Function]
+      #
+      def transproc
+        Functions[:group, key, selector]
+      end
+
+    end # class Group
+
+  end # module Nodes
+
+end # module Faceter

data/lib/faceter/nodes/list.rb

@@ -0,0 +1,25 @@
+module Faceter
+
+  # The collection of faceter-specific nodes of the AST
+  #
+  module Nodes
+
+    # The composed node that describes an array of the input data
+    #
+    # @api private
+    #
+    class List < AbstractMapper::Branch
+
+      # Builds a transproc function for the node from its child nodes
+      #
+      # @return [Transproc::Function]
+      #
+      def transproc
+        Functions[:map_array, super]
+      end
+
+    end # class List
+
+  end # module Nodes
+
+end # module Faceter

data/lib/faceter/nodes/remove_prefix.rb

@@ -0,0 +1,21 @@
+module Faceter
+
+  module Nodes
+
+    # The node describes removing prefix from tuples' keys
+    #
+    # @api private
+    #
+    class RemovePrefix < ChangePrefix
+
+      private
+
+      def __operation__
+        :drop_prefix
+      end
+
+    end # class RemovePrefix
+
+  end # module Nodes
+
+end # module Faceter

data/lib/faceter/nodes/rename.rb

@@ -0,0 +1,25 @@
+module Faceter
+
+  module Nodes
+
+    # The node describes renaming a key of tuples
+    #
+    # @api private
+    #
+    class Rename < AbstractMapper::Node
+
+      attribute :keys, default: {}
+
+      # Transformer function, defined by the node
+      #
+      # @return [Transproc::Function]
+      #
+      def transproc
+        Functions[:rename_keys, keys]
+      end
+
+    end # class Rename
+
+  end # module Nodes
+
+end # module Faceter

data/lib/faceter/nodes/stringify_keys.rb

@@ -0,0 +1,26 @@
+module Faceter
+
+  module Nodes
+
+    # The node describes stringifying keys of tuple (and its nested tuples)
+    #
+    # @api private
+    #
+    class StringifyKeys < AbstractMapper::Node
+
+      attribute :nested, default: true
+
+      # Transformer function, defined by the node
+      #
+      # @return [Transproc::Function]
+      #
+      def transproc
+        fn = Functions[:stringify_keys]
+        nested ? Functions[:recursion, Functions[:is, Hash, fn]] : fn
+      end
+
+    end # class StringifyKeys
+
+  end # module Nodes
+
+end # module Faceter

data/lib/faceter/nodes/symbolize_keys.rb

@@ -0,0 +1,26 @@
+module Faceter
+
+  module Nodes
+
+    # The node describes stringifying keys of tuple (and its nested tuples)
+    #
+    # @api private
+    #
+    class SymbolizeKeys < AbstractMapper::Node
+
+      attribute :nested, default: true
+
+      # Transformer function, defined by the node
+      #
+      # @return [Transproc::Function]
+      #
+      def transproc
+        fn = Functions[:symbolize_keys]
+        nested ? Functions[:recursion, Functions[:is, Hash, fn]] : fn
+      end
+
+    end # class SymbolizeKeys
+
+  end # module Nodes
+
+end # module Faceter

data/lib/faceter/nodes/unfold.rb

@@ -0,0 +1,25 @@
+module Faceter
+
+  module Nodes
+
+    # The node describes exclusion of the field from a tuple
+    #
+    # @api private
+    #
+    class Unfold < AbstractMapper::Node
+
+      attribute :key
+
+      # Transformer function, defined by the node
+      #
+      # @return [Transproc::Function]
+      #
+      def transproc
+        Functions[-> hash { hash[key] }]
+      end
+
+    end # class Unfold
+
+  end # module Nodes
+
+end # module Faceter

data/lib/faceter/nodes/ungroup.rb

@@ -0,0 +1,26 @@
+module Faceter
+
+  module Nodes
+
+    # The node describes grouping fields from nested arrays to tuples
+    #
+    # @api private
+    #
+    class Ungroup < AbstractMapper::Node
+
+      attribute :key
+      attribute :selector
+
+      # Transformer function, defined by the node
+      #
+      # @return [Transproc::Function]
+      #
+      def transproc
+        Functions[:ungroup, key, selector]
+      end
+
+    end # class Ungroup
+
+  end # module Nodes
+
+end # module Faceter

data/lib/faceter/nodes/unwrap.rb

@@ -0,0 +1,26 @@
+module Faceter
+
+  module Nodes
+
+    # The node describes unwrapping values from the nested tuples
+    #
+    # @api private
+    #
+    class Unwrap < AbstractMapper::Node
+
+      attribute :key
+      attribute :selector
+
+      # Transformer function, defined by the node
+      #
+      # @return [Transproc::Function]
+      #
+      def transproc
+        Functions[:unwrap, key, selector]
+      end
+
+    end # class Unwrap
+
+  end # module Nodes
+
+end # module Faceter

data/lib/faceter/nodes/wrap.rb

@@ -0,0 +1,26 @@
+module Faceter
+
+  module Nodes
+
+    # The node describes wrapping hash values into nested tuple
+    #
+    # @api private
+    #
+    class Wrap < AbstractMapper::Node
+
+      attribute :key
+      attribute :selector
+
+      # Transformer function, defined by the node
+      #
+      # @return [Transproc::Function]
+      #
+      def transproc
+        Functions[:wrap, key, selector]
+      end
+
+    end # class Wrap
+
+  end # module Nodes
+
+end # module Faceter

data/lib/faceter/rules/append_nested.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+module Faceter
+
+  module Rules
+
+    # Does the same as [Faceter::Rules::PrependNested] in case
+    # 'nested' transformation follows the `List`, not prepends it.
+    #
+    # @api private
+    #
+    class AppendNested < AbstractMapper::PairRule
+
+      # @private
+      def optimize?
+        left.instance_of?(Nodes::List) && right.respond_to?(:nested)
+      end
+
+      # @private
+      def optimize
+        Nodes::List.new { left.entries + (right.nested ? [right] : []) }
+      end
+
+    end # class AppendNested
+
+  end # module Rules
+
+end # module Faceter

data/lib/faceter/rules/merge_branches.rb

@@ -0,0 +1,41 @@
+# encoding: utf-8
+
+module Faceter
+
+  # Collection of optimization rules for AST
+  #
+  module Rules
+
+    # Merges two consecutive branches of the same type
+    #
+    # @api private
+    #
+    class MergeBranches < AbstractMapper::PairRule
+
+      # @private
+      def optimize?
+        left.is_a?(AbstractMapper::Branch) &&
+          right.class.equal?(__left_node__) &&
+          right.attributes.eql?(__left_attributes__)
+      end
+
+      # @private
+      def optimize
+        __left_node__.new(__left_attributes__) { nodes.flat_map(&:entries) }
+      end
+
+      private
+
+      def __left_node__
+        left.class
+      end
+
+      def __left_attributes__
+        left.attributes
+      end
+
+    end # class MergeBranches
+
+  end # module Rules
+
+end # module Faceter

data/lib/faceter/rules/merge_excludes.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+module Faceter
+
+  # Collection of optimization rules for AST
+  #
+  module Rules
+
+    # Merges two consecutive nodes that exclude keys
+    #
+    # @api private
+    #
+    class MergeExcludes < AbstractMapper::PairRule
+
+      # @private
+      def optimize?
+        nodes.map { |node| node.instance_of? Nodes::Exclude }.reduce(:&)
+      end
+
+      # @private
+      def optimize
+        Nodes::Exclude.new(selector: nodes.map(&:selector).reduce(:|))
+      end
+
+    end # class MergeExcludes
+
+  end # module Rules
+
+end # module Faceter

data/lib/faceter/rules/merge_renames.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+
+module Faceter
+
+  module Rules
+
+    # Merges two consecutive renames
+    #
+    # @api private
+    #
+    class MergeRenames < AbstractMapper::PairRule
+
+      # @private
+      def optimize?
+        nodes.map { |node| node.instance_of? Nodes::Rename }.reduce(:&)
+      end
+
+      # @private
+      def optimize
+        Nodes::Rename.new keys: nodes.map(&:keys).reduce(:merge)
+      end
+
+    end # class MergeRenames
+
+  end # module Rules
+
+end # module Faceter

data/lib/faceter/rules/order_fields.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+
+module Faceter
+
+  module Rules
+
+    # Orders consecutive fields by their names to allow merging them later
+    #
+    class OrderFields < AbstractMapper::Rule
+
+      # @private
+      def optimize?
+        true
+      end
+
+      # @private
+      def optimize
+        Functions[:claster, -> v { v.class }][nodes].flat_map do |list|
+          list.last.instance_of?(Nodes::Field) ? list.sort_by(&:key) : list
+        end
+      end
+
+    end # class OrderFields
+
+  end # module Rules
+
+end # module Faceter