faceter 0.0.1

data/lib/faceter/functions/drop_prefix.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+module Faceter
+
+  module Functions
+
+    # Removes the prefix with separator from the string
+    #
+    # @example
+    #   fn = Functions[:drop_prefix, "foo", "."]
+    #   fn["foo.bar"]  # => "bar"
+    #
+    # @param [#to_s] string
+    # @param [#to_s] prefix
+    # @param [#to_sl] separator
+    #
+    # @return [String]
+    #
+    def self.drop_prefix(string, prefix, separator)
+      str   = string.to_s
+      affix = "#{prefix}#{separator}"
+      first = str.start_with?(affix) ? affix.length : 0
+
+      str[first..-1]
+    end
+
+  end # module Functions
+
+end # module Faceter

data/lib/faceter/functions/exclude.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+
+module Faceter
+
+  module Functions
+
+    # Excludes keys, that satisfies the selector, from the hash
+    #
+    # @example
+    #   selector = Selector.new(only: /b/)
+    #   function = Functions[:exclude, selector]
+    #
+    #   function[{ foo: :FOO, bar: :BAR, baz: :BAZ }]
+    #   # => { foo: :FOO }
+    #
+    # @param [Hash] hash
+    # @param [Selector::Condition] selector
+    #
+    # @return [Array<Hash>]
+    #
+    def self.exclude(hash, selector)
+      hash.reject { |key| selector[key] }
+    end
+
+  end # module Functions
+
+end # module Faceter

data/lib/faceter/functions/group.rb

@@ -0,0 +1,41 @@
+# encoding: utf-8
+
+module Faceter
+
+  module Functions
+
+    # Groups array values using provided root key and selector
+    #
+    # @example
+    #   selector = Selector.new(only: [:bar])
+    #   function = Functions[:group, :qux, selector]
+    #
+    #   function[[{ foo: :FOO, bar: :BAR }, { foo: :FOO, bar: :BAZ }]]
+    #   # => [{ foo: :FOO, qux: [{ bar: :BAR }, { bar: :BAZ }] }]
+    #
+    # @param [Array] array
+    # @param [Object] key
+    # @param [Selector::Condition] selector
+    #
+    # @return [Array<Hash>]
+    #
+    def self.group(array, key, selector)
+      tuples = Hash.new { |h, k| h[k] = [] }
+
+      array.each do |hash|
+        to_group, to_keep = split(Hash[hash], selector)
+        grouped = t(:to_tuples)[to_keep[key]]
+        to_keep.delete(key)
+
+        tuples[to_keep] << grouped.map { |item| item.merge(to_group) }
+      end
+
+      tuples.map do |root, children|
+        list = children.flatten
+        list.first.empty? ? root : root.merge(key => list)
+      end
+    end
+
+  end # module Functions
+
+end # module Faceter

data/lib/faceter/functions/keep_symbol.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+
+module Faceter
+
+  module Functions
+
+    # Applies the function to the source and converts the result to symbol
+    # if the source data was a symbol.
+    #
+    # @example
+    #   fn = Functions[:keep_symbol, -> v { v.to_s.reverse }]
+    #   fn["123"] # => "321"
+    #   fn[:123]  # => :321
+    #
+    # @param [Object] source
+    # @param [Transproc::Function] fn
+    #
+    # @return [String, Symbol]
+    #
+    def self.keep_symbol(source, fn)
+      data = fn.call(source)
+      source.instance_of?(Symbol) ? data.to_s.to_sym : data
+    end
+
+  end # module Functions
+
+end # module Faceter

data/lib/faceter/functions/split.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+module Faceter
+
+  module Functions
+
+    # Splits the hash into two parts using a selector
+    #
+    # @example
+    #   selector = Selector.new(except: /r/)
+    #   function = Functions[:split, selector]
+    #
+    #   function[{ foo: :FOO, bar: :BAR, baz: :BAZ }]
+    #   # => [{ foo: :FOO, baz: :BAZ }, { bar: :BAR }]
+    #
+    # @param [Hash] hash
+    # @param [Selector::Condition] selector
+    #
+    # @return [Array<Hash>]
+    #
+    def self.split(hash, selector)
+      fn = -> key, _ { selector[key] }
+      [hash.select(&fn), hash.reject(&fn)]
+    end
+
+  end # module Functions
+
+end # module Faceter

data/lib/faceter/functions/ungroup.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+module Faceter
+
+  module Functions
+
+    # Ungroups array values using provided root key and selector
+    #
+    # @example
+    #   selector = Selector.new(only: :bar)
+    #   function = Functions[:ungroup, :qux, selector]
+    #
+    #   function[[{ foo: :FOO, qux: [{ bar: :BAR }, { bar: :BAZ }] }]]
+    #   # => [{ foo: :FOO, bar: :BAR }, { foo: :FOO, bar: :BAZ }]
+    #
+    # @param [Array] array
+    # @param [Object] key
+    # @param [Selector::Condition] selector
+    #
+    # @return [Array<Hash>]
+    #
+    def self.ungroup(array, key, selector)
+      array.flat_map do |hash|
+        list = t(:to_tuples)[hash.delete(key)]
+        group(list, key, !selector).map { |item| hash.merge(item) }
+      end
+    end
+
+  end # module Functions
+
+end # module Faceter

data/lib/faceter/functions/unwrap.rb

@@ -0,0 +1,32 @@
+# encoding: utf-8
+
+module Faceter
+
+  module Functions
+
+    # Partially unwraps a subhash under the hash key following the selector
+    #
+    # @example
+    #   selector = Selector.new(only: :bar)
+    #   function = Functions[:unwrap, :foo, selector]
+    #
+    #   function[foo: { bar: :BAR, baz: :BAZ }, qux: :QUX]
+    #   # => { qux: :QUX, foo: { baz: :BAZ }, bar: :BAR }
+    #
+    # @param [Hash] hash
+    # @param [Object] key
+    # @param [Selector::Condition] selector
+    #
+    # @return Hash
+    #
+    def self.unwrap(hash, key, selector)
+      extracted, keep = split(hash.fetch(key, {}), selector)
+      cleaner = Selector.new(only: key)
+
+      clean_hash = clean(hash.merge(key => keep), cleaner)
+      clean_hash.merge(extracted)
+    end
+
+  end # module Functions
+
+end # module Faceter

data/lib/faceter/functions/wrap.rb

@@ -0,0 +1,32 @@
+# encoding: utf-8
+
+module Faceter
+
+  module Functions
+
+    # Partially wraps a subhash into the new key following the selector
+    #
+    # @example
+    #   selector = Selector.new(only: :bar)
+    #   function = Functions[:wrap, :foo, selector]
+    #
+    #   function[foo: { baz: :BAZ }, bar: :BAR, qux: :QUX]
+    #   # => { foo: { baz: :BAZ, bar: :BAR }, qux: :QUX }
+    #
+    # @param [Hash] hash
+    # @param [Object] key
+    # @param [Selector::Condition] selector
+    #
+    # @return Hash
+    #
+    def self.wrap(hash, key, selector)
+      to_wrap, to_keep = split(hash, selector)
+      wrapped = to_keep[key]
+
+      to_wrap = wrapped.merge(to_wrap) if wrapped.instance_of? Hash
+      to_keep.merge(key => to_wrap)
+    end
+
+  end # module Functions
+
+end # module Faceter

data/lib/faceter/mapper.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8
+
+module Faceter
+
+  # The base class for mappers
+  #
+  # @api private
+  #
+  class Mapper < AbstractMapper
+    configure do
+
+      # List of mapper commands
+      command :add_prefix,     Nodes::AddPrefix,    &Coercers[:prefix]
+      command :create,         Nodes::Create,       &Coercers[:create]
+      command :exclude,        Nodes::Exclude,      &Coercers[:exclude]
+      command :field,          Nodes::Field,        &Coercers[:field]
+      command :fold,           Nodes::Fold,         &Coercers[:fold]
+      command :group,          Nodes::Group,        &Coercers[:wrap]
+      command :list,           Nodes::List
+      command :remove_prefix,  Nodes::RemovePrefix, &Coercers[:prefix]
+      command :rename,         Nodes::Rename,       &Coercers[:rename]
+      command :stringify_keys, Nodes::StringifyKeys
+      command :symbolize_keys, Nodes::SymbolizeKeys
+      command :unfold,         Nodes::Unfold,       &Coercers[:unfold]
+      command :ungroup,        Nodes::Ungroup,      &Coercers[:unwrap]
+      command :unwrap,         Nodes::Unwrap,       &Coercers[:unwrap]
+      command :wrap,           Nodes::Wrap,         &Coercers[:wrap]
+
+      # List of optimization rules
+      rule Rules::PrependNested
+      rule Rules::AppendNested
+      rule Rules::MergeBranches
+      rule Rules::MergeRenames
+
+    end
+  end # class Mapper
+
+end # module Faceter

data/lib/faceter/nodes/add_prefix.rb

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

data/lib/faceter/nodes/change_prefix.rb

@@ -0,0 +1,51 @@
+module Faceter
+
+  module Nodes
+
+    # The base class for prefix-manipulating nodes
+    #
+    # see [Faceter::Nodes::AddPrefix]
+    # see [Faceter::Nodes::RemovePrefix]
+    #
+    # @abstract
+    #
+    # @api private
+    #
+    class ChangePrefix < AbstractMapper::Node
+
+      attribute :prefix
+      attribute :separator, default: "_"
+      attribute :nested, default: false
+      attribute :selector
+
+      # Transformer function, defined by the node
+      #
+      # @return [Transproc::Function]
+      #
+      def transproc
+        return __transformation__ unless nested
+        Functions[:recursion, Functions[:is, Hash, __transformation__]]
+      end
+
+      private
+
+      def __transformation__
+        Functions[:map_keys, __selected__]
+      end
+
+      def __selected__
+        return __function__ unless selector
+        Functions[:guard, selector, __function__]
+      end
+
+      def __function__
+        Functions[:keep_symbol, Functions[__operation__, prefix, separator]]
+      end
+
+      # __operation__ should be defined in a specific node
+
+    end # class AddPrefix
+
+  end # module Nodes
+
+end # module Faceter

data/lib/faceter/nodes/create.rb

@@ -0,0 +1,43 @@
+module Faceter
+
+  module Nodes
+
+    # The node describes creating a new value from values by keys
+    #
+    # @api private
+    #
+    class Create < AbstractMapper::Node
+
+      attribute :name
+      attribute :keys
+
+      # Transformer function, defined by the node
+      #
+      # @return [Transproc::Function]
+      #
+      def transproc
+        Functions[__fn__]
+      end
+
+      private
+
+      def __fn__
+        return __proc__ unless name
+        -> hash { hash.merge(name => __proc__[hash]) }
+      end
+
+      def __proc__
+        return __values__ unless block
+        -> hash { block[*__values__[hash]] }
+      end
+
+      def __values__
+        return -> hash { hash.fetch(keys) } unless keys.instance_of?(Array)
+        -> hash { hash.values_at(*keys) }
+      end
+
+    end # class Create
+
+  end # module Nodes
+
+end # module Faceter

data/lib/faceter/nodes/exclude.rb

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

data/lib/faceter/nodes/field.rb

@@ -0,0 +1,25 @@
+module Faceter
+
+  module Nodes
+
+    # The composed node that describes a field of tuples in input data
+    #
+    # @api private
+    #
+    class Field < AbstractMapper::Branch
+
+      attribute :key
+
+      # Builds a transproc function for the field node from its child nodes
+      #
+      # @return [Transproc::Function]
+      #
+      def transproc
+        Functions[:map_value, key, super]
+      end
+
+    end # class Field
+
+  end # module Nodes
+
+end # module Faceter