abstract_mapper 0.0.1 → 0.0.2

data/lib/abstract_mapper/command.rb

@@ -0,0 +1,68 @@
+# encoding: utf-8
+
+class AbstractMapper
+
+  # Describes the command of the mapper
+  #
+  # Every command has a name, a node that is added to the AST and the function,
+  # that converts command attributes into the node's.
+  #
+  # Method `#call` builds a correspodning node for the AST.
+  #
+  # @api private
+  #
+  class Command
+
+    # @!attribute [r] name
+    #
+    # @return [Symbol] The name of the DSL command
+    #
+    attr_reader :name
+
+    # @!attribute [r] klass
+    #
+    # @return [Class] The class of the node to be created
+    #
+    attr_reader :klass
+
+    # @!attribute [r] converter
+    #
+    # @return [#call] The converter of the command's arguments into the node's
+    #
+    attr_reader :converter
+
+    # @!scope class
+    # @!method new(name, klass, converter)
+    # Creates the named command for node klass and arguments converter
+    #
+    # @param [#to_sym] name The name of the DSL command
+    # @param [Class] klass The klass of the node to be created
+    # @param [#call] converter The function that coerces attributes
+    #
+    # @return [AbstractMapper::Command]
+
+    # @private
+    def initialize(name, klass, converter = nil)
+      @name = name.to_sym
+      @klass = klass
+      @branch = Functions[:subclass?, Branch][klass]
+      @converter = converter || proc { |args = {}| args }
+      IceNine.deep_freeze(self)
+    end
+
+    # Builds the AST node
+    #
+    # @param [Object, Array] args
+    #   The argument of the command that should be converted to node attributes
+    # @param [Proc] block
+    #
+    # @return [AbstractMapper::Node]
+    #
+    def call(*args, &block)
+      block = nil if @branch
+      klass.new(converter.call(*args), &block)
+    end
+
+  end # class Command
+
+end # class AbstractMapper

data/lib/abstract_mapper/commands.rb

@@ -2,20 +2,12 @@
 
 class AbstractMapper
 
-  # Registry of DSL commands used by the builder
+  # Collection of DSL commands used by the builder
   #
   # @api private
   #
   class Commands
 
-    # @!attribute [r] registry
-    #
-    # @return [Hash<Symbol => Class>]
-    #   The registry of command names, pointing to types of the nodes,
-    #   that should be built for adding to AST
-    #
-    attr_reader :registry
-
     # @!scope class
     # @!method new(registry = {})
     # Creates an immutable collection of commands
@@ -26,44 +18,32 @@ class AbstractMapper
 
     # @private
     def initialize(registry = {})
-      @registry = registry.dup.freeze
-      freeze
+      @registry = registry.dup
+      IceNine.deep_freeze(self)
     end
 
     # Returns a new immutable registry with added command name and type
     #
-    # @param [Array<Symbol, Class>] other
+    # @param [[Symbol, Class, Proc]] other
     #
     # @return [undefined]
     #
     def <<(other)
-      name = other[0]
-      node = other[1]
-      self.class.new registry.merge(name.to_sym => node)
+      command = Command.new(*other)
+      self.class.new @registry.merge(command.name => command)
     end
 
-    # Builds a node by the name of DSL command
-    #
-    # Skips the block if a registered node is a branch
+    # Returns the registered command by name
     #
     # @param [#to_sym] name The name of the command
-    # @param [Object, Array] args The command's arguments
-    # @param [Proc] block
-    #   The block to be passed to the constructor of the simple node
+    #
+    # @return [AbstractMapper::Command]
     #
     # @raise [AbstractMapper::Errors::UnknownCommand]
     #   When unknown command is called
     #
-    def [](name, *args, &block)
-      type   = get(name)
-      branch = Functions[:subclass?, Branch][type]
-      branch ? type.new(*args) : type.new(*args, &block)
-    end
-
-    private
-
-    def get(name)
-      registry.fetch(name.to_sym) { fail(Errors::UnknownCommand.new name) }
+    def [](name)
+      @registry.fetch(name.to_sym) { fail(Errors::UnknownCommand.new name) }
     end
 
   end # class Commands

data/lib/abstract_mapper/errors/unknown_command.rb

@@ -15,7 +15,7 @@ class AbstractMapper
       # @private
       def initialize(name)
         super "'#{name}' is not a registered DSL command"
-        freeze
+        IceNine.deep_freeze(self)
       end
 
     end # class UnknownCommand

data/lib/abstract_mapper/errors/wrong_node.rb

@@ -13,7 +13,7 @@ class AbstractMapper
       # @private
       def initialize(node)
         super "#{node} is not a subclass of AbstractMapper::Node"
-        freeze
+        IceNine.deep_freeze(self)
       end
 
     end # class WrongNode

data/lib/abstract_mapper/errors/wrong_rule.rb

@@ -12,8 +12,8 @@ class AbstractMapper
 
       # @private
       def initialize(node)
-        super "#{node} is not a subclass of AbstractMapper::SoleRule"
-        freeze
+        super "#{node} is not a subclass of AbstractMapper::Rule"
+        IceNine.deep_freeze(self)
       end
 
     end # class WrongRule

data/lib/abstract_mapper/functions.rb

@@ -10,7 +10,21 @@ class AbstractMapper
 
     extend Transproc::Registry
 
-    uses :map_array, from: Transproc::ArrayTransformations
+    import :map_array, from: Transproc::ArrayTransformations
+
+    # Returns the unchanged value whatever parameters are given
+    #
+    # @example
+    #   fn = Functions[:identity, :foo]
+    #   fn[1] # => 1
+    #
+    # @param [Object] value
+    #
+    # @return [Object]
+    #
+    def self.identity(value, *)
+      value
+    end
 
     # Applies the function to every element of array and removes empty values
     #
@@ -24,8 +38,8 @@ class AbstractMapper
     #
     # @return [Array]
     #
-    def filter(array, fn)
-      map_array(array, fn).compact.flatten
+    def self.filter(array, fn)
+      t(:map_array, fn)[array].compact.flatten
     end
 
     # Applies the function to every consecutive pair of array elements,
@@ -44,7 +58,7 @@ class AbstractMapper
     #
     # @return [Array]
     #
-    def compact(array, fn)
+    def self.compact(array, fn)
       array.each_with_object([]) do |i, a|
         if a.empty?
           a << i
@@ -67,10 +81,23 @@ class AbstractMapper
     #
     # @return [Boolean]
     #
-    def subclass?(subling, ancestor)
+    def self.subclass?(subling, ancestor)
       subling.ancestors.include?(ancestor)
     end
 
+    # Restricts the hash by keys and values of the default one
+    #
+    # @param [Hash] hash
+    # @param [Hash] default_hash
+    #
+    # @return [Hash] <description>
+    #
+    def self.restrict(hash, default_hash)
+      keys = default_hash.keys
+      values = default_hash.merge(hash).values
+      Hash[keys.zip(values)]
+    end
+
   end # module Functions
 
 end # class AbstractMapper

data/lib/abstract_mapper/node.rb

@@ -17,11 +17,8 @@ class AbstractMapper
   #
   class Node
 
-    # @!attribute [r] attributes
-    #
-    # @return [Array] The list of node-specific attributes
-    #
-    attr_reader :attributes
+    include Attributes # adds attributes and their DSL
+    include Comparable
 
     # @!attribute [r] block
     #
@@ -30,19 +27,21 @@ class AbstractMapper
     attr_reader :block
 
     # @private
-    def initialize(*attributes, &block)
-      @attributes = attributes.freeze
+    def initialize(_ = {}, &block)
+      super
       @block      = block
-      freeze
+      IceNine.deep_freeze(self)
     end
 
     # @!method transproc
     # The transformation function for the branch
     #
+    # @return [Transproc::Function]
+    #
     # @abstract
     #
     def transproc
-      Transproc::Function.new(-> v { v }, {})
+      Functions[:identity]
     end
 
     # Returns a human-readable string representating the node
@@ -61,6 +60,17 @@ class AbstractMapper
       "#{__name__}#{__attributes__}"
     end
 
+    # Compares the node to another one by type and attributes
+    #
+    # @param [Object] other
+    #
+    # @return [Boolean]
+    #
+    def ==(other)
+      other.instance_of?(self.class) && attributes.eql?(other.attributes)
+    end
+    alias_method :eql?, :==
+
     private
 
     def __name__
@@ -68,7 +78,8 @@ class AbstractMapper
     end
 
     def __attributes__
-      "(#{attributes.map(&:inspect).join(", ")})" if attributes.any?
+      return if attributes.empty?
+      "(#{attributes.map { |k, v| "#{k}: #{v.inspect}" }.join(", ")})"
     end
 
   end # class Node

data/lib/abstract_mapper/optimizer.rb

@@ -28,7 +28,7 @@ class AbstractMapper
     # @private
     def initialize(rules)
       @rules = rules
-      freeze
+      IceNine.deep_freeze(self)
     end
 
     # Recursively optimizes the AST from root to leafs
@@ -39,8 +39,8 @@ class AbstractMapper
     #
     def update(tree)
       return tree unless tree.is_a? Branch
-      new_tree = tree.rebuild { rules[tree] }
-      new_tree.rebuild { new_tree.map(&method(:update)) }
+      new_tree = tree.update { rules[tree] }
+      new_tree.update { new_tree.map(&method(:update)) }
     end
 
   end # class Optimizer

data/lib/abstract_mapper/pair_rule.rb

@@ -26,13 +26,11 @@ class AbstractMapper
   #
   class PairRule < Rule
 
-    # Returns the name of transproc used to compose rules
-    #
-    # @return [Symbol]
-    #
+    # @private
     def self.composer
       :compact
     end
+    private_class_method :composer
 
     # @!attribute [r] node
     #

data/lib/abstract_mapper/rspec.rb

@@ -1,7 +1,6 @@
 # encoding: utf-8
 
 # Collection of shared examples for testing parts of DSL
-require_relative "../rspec/functions"
 require_relative "../rspec/nodes"
 require_relative "../rspec/rules"
-require_relative "../rspec/mapper"
+require_relative "../rspec/doubles"

data/lib/abstract_mapper/rule.rb

@@ -10,6 +10,12 @@ class AbstractMapper
   #
   class Rule
 
+    # @private
+    def self.composer
+      :identity
+    end
+    private_class_method :composer
+
     # The transformation function that applies the rule to the array of nodes
     #
     # @return [Transproc::Function]
@@ -35,8 +41,23 @@ class AbstractMapper
 
     # @private
     def initialize(*nodes)
-      @nodes = nodes.freeze
-      freeze
+      @nodes = nodes
+      IceNine.deep_freeze(self)
+    end
+
+    # Checks if optimization is needed for the node(s)
+    #
+    # @return [Boolean]
+    #
+    def optimize?
+    end
+
+    # Returns the optimized node(s)
+    #
+    # @return [Object]
+    #
+    def optimize
+      nodes
     end
 
     # Returns the result of the rule applied to the initialized [#nodes]

data/lib/abstract_mapper/rules.rb

@@ -24,9 +24,9 @@ class AbstractMapper
 
     # @private
     def initialize(registry = [])
-      @registry  = registry.dup.freeze
-      @transproc = ordered.map(&:transproc).inject(:>>)
-      freeze
+      @registry  = registry.dup
+      @transproc = registry.map(&:transproc).inject(:>>)
+      IceNine.deep_freeze(self)
     end
 
     # Returns the copy of current registry with the new rule added
@@ -49,13 +49,6 @@ class AbstractMapper
       @transproc ? @transproc[nodes] : nodes
     end
 
-    private
-
-    # Calls all sole rules first
-    def ordered
-      registry.sort_by { |rule| Functions[:subclass?, PairRule][rule].to_s }
-    end
-
   end # class Rules
 
 end # class AbstractMapper

data/lib/abstract_mapper/settings.rb

@@ -52,7 +52,7 @@ class AbstractMapper
       __configure__(&block)
       __set_builder__
       __set_optimizer__
-      freeze
+      IceNine.deep_freeze(self)
     end
 
     private
@@ -63,10 +63,10 @@ class AbstractMapper
       @rules = rules << value
     end
 
-    def command(name, node)
+    def command(name, node, &block)
       fn = Functions[:subclass?, Node]
       fail Errors::WrongNode.new(node) unless fn[node]
-      @commands = commands << [name, node]
+      @commands = commands << [name, node, block]
     end
 
     def __set_rules__

data/lib/abstract_mapper/sole_rule.rb

@@ -25,13 +25,11 @@ class AbstractMapper
   #
   class SoleRule < Rule
 
-    # Returns the name of transproc used to compose rules
-    #
-    # @return [Symbol]
-    #
+    # @private
     def self.composer
       :filter
     end
+    private_class_method :composer
 
     # @!attribute [r] node
     #