abstract_mapper 0.0.2 → 0.1.0

data/lib/abstract_mapper/dsl.rb

@@ -31,7 +31,7 @@ class AbstractMapper
     # @yield a block
     #
     def configure(&block)
-      @settings = Settings.new(&block)
+      @settings = settings ? settings.update(&block) : Settings.new(&block)
       self
     end
 
@@ -46,7 +46,7 @@ class AbstractMapper
     private # DSL commands
 
     def tree
-      @tree ||= Branch.new
+      @tree ||= AST::Branch.new
     end
 
     def respond_to_missing?(*)

data/lib/abstract_mapper/errors.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+class AbstractMapper
+
+  # The namespace for the gem-specific exceptions
+  #
+  # @author Andrew Kozin <Andrew.Kozin@gmail.com>
+  #
+  module Errors
+
+    require_relative "errors/unknown_command"
+    require_relative "errors/wrong_node"
+    require_relative "errors/wrong_rule"
+
+  end # module Errors
+
+end # class AbstractMapper

data/lib/abstract_mapper/errors/wrong_node.rb

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

data/lib/abstract_mapper/errors/wrong_rule.rb

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

data/lib/abstract_mapper/optimizer.rb

@@ -38,7 +38,7 @@ class AbstractMapper
     # @return [AbstractMapper::Branch]
     #
     def update(tree)
-      return tree unless tree.is_a? Branch
+      return tree unless tree.is_a? AST::Branch
       new_tree = tree.update { rules[tree] }
       new_tree.update { new_tree.map(&method(:update)) }
     end

data/lib/abstract_mapper/rules.rb

@@ -2,6 +2,10 @@
 
 class AbstractMapper
 
+  require_relative "rules/base"
+  require_relative "rules/sole"
+  require_relative "rules/pair"
+
   # Registry of DSL rules applicable to nodes of AST
   #
   # @api private
@@ -10,7 +14,8 @@ class AbstractMapper
 
     # @!attribute [r] registry
     #
-    # @return [Array<AbstractMapper::SoleRule>] list of rules applicable to AST
+    # @return [Array<AbstractMapper::Rules::Base>]
+    #   the list of rules applicable to AST
     #
     attr_reader :registry
 
@@ -18,7 +23,7 @@ class AbstractMapper
     # @!method new(registry)
     # Creates a registry with array of rules
     #
-    # @param [Array<AbstractMapper::SoleRule>] registry Array of rules
+    # @param [Array<AbstractMapper::Rules::Base>] registry Array of rules
     #
     # @return [AbstractMapper::Rules]
 
@@ -31,7 +36,7 @@ class AbstractMapper
 
     # Returns the copy of current registry with the new rule added
     #
-    # @param [AbstractMapper::SoleRule] other
+    # @param [AbstractMapper::Rules::Base] other
     #
     # @return (see #new)
     #
@@ -41,9 +46,9 @@ class AbstractMapper
 
     # Applies all the registered rules to the array of nodes
     #
-    # @param [Array<AbstractMapper::Node>] nodes
+    # @param [Array<AbstractMapper::AST::Node>] nodes
     #
-    # @return [Array<AbstractMapper::Node>] The optimized array of nodes
+    # @return [Array<AbstractMapper::AST::Node>] The optimized array of nodes
     #
     def [](nodes)
       @transproc ? @transproc[nodes] : nodes

data/lib/abstract_mapper/rules/base.rb

@@ -0,0 +1,74 @@
+# encoding: utf-8
+
+class AbstractMapper
+
+  class Rules
+
+    # Base class for optimization rules
+    #
+    # @abstract
+    #
+    # @api private
+    #
+    class Base
+
+      # @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]
+      #
+      def self.transproc
+        Functions[composer, proc { |*nodes| new(*nodes).call }]
+      end
+
+      # @!attribute [r] nodes
+      #
+      # @return [Array<AbstractMapper::AST::Node>]
+      #   Either one or two nodes to be optimized
+      #
+      attr_reader :nodes
+
+      # Initializes the rule for a sole node, or a pair of consecutive nodes
+      #
+      # @param [Array<AbstractMapper::AST::Node>] nodes
+      #
+      # @return [AbstractMapper::Rules::Base]
+      #
+      def initialize(*nodes)
+        @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]
+      #
+      # @return [Array<AbstractMapper::AST::Node>]
+      #
+      def call
+        optimize? ? [optimize].flatten.compact : nodes
+      end
+
+    end # class Base
+
+  end # class Rules
+
+end # class AbstractMapper

data/lib/abstract_mapper/rules/pair.rb

@@ -0,0 +1,68 @@
+# encoding: utf-8
+
+class AbstractMapper
+
+  class Rules
+
+    # The base class for rules to be applied to pairs of nodes.
+    #
+    # The subclass should implement two instance methods:
+    #
+    # * `#optimize?` to check if the optimization should be applied to the nodes
+    # * `#optimize` that should return the merged node
+    #
+    # @example
+    #   class MergeConsecutiveLists < AbstractMapper::Rules::Pair
+    #     def optimize?
+    #       left.is_a?(List) & right.is_a?(List)
+    #     end
+    #
+    #     def optimize
+    #       List.new { left.entries + right.entries }
+    #     end
+    #   end
+    #
+    # @abstract
+    #
+    # @api public
+    #
+    class Pair < Base
+
+      # @private
+      def self.composer
+        :compact
+      end
+      private_class_method :composer
+
+      # @!attribute [r] node
+      #
+      # @return [AbstractMapper::AST::Node] The left node in the pair
+      #
+      attr_reader :left
+
+      # @!attribute [r] node
+      #
+      # @return [AbstractMapper::AST::Node] The right node in the pair
+      #
+      attr_reader :right
+
+      # @!scope class
+      # @!method new(node)
+      # Creates a rule applied to the sole node
+      #
+      # @param [AbstractMapper::AST::Node] node
+      #
+      # @return [AbstractMapper::Rules::Base]
+
+      # @private
+      def initialize(left, right)
+        @left  = left
+        @right = right
+        super
+      end
+
+    end # class Pair
+
+  end # class Rule
+
+end # class AbstractMapper

data/lib/abstract_mapper/rules/sole.rb

@@ -0,0 +1,60 @@
+# encoding: utf-8
+
+class AbstractMapper
+
+  class Rules
+
+    # The abstract class that describes the rule to be applied to sole nodes.
+    #
+    # The subclass should implement two instance methods:
+    #
+    # * `#optimize?` to check if the optimization should be applied to the node
+    # * `#optimize` that should return the optimized node
+    #
+    # @example
+    #   class RemoveEmptyList < AbstractMapper::Rules::Sole
+    #     def optimize?
+    #       node.is_a?(List) && node.empty?
+    #     end
+    #
+    #     def optimize
+    #     end
+    #   end
+    #
+    # @abstract
+    #
+    # @api public
+    #
+    class Sole < Base
+
+      # @private
+      def self.composer
+        :filter
+      end
+      private_class_method :composer
+
+      # @!attribute [r] node
+      #
+      # @return [AbstractMapper::AST::Node] The node to be optimized
+      #
+      attr_reader :node
+
+      # @!scope class
+      # @!method new(node)
+      # Creates a rule applied to the sole node
+      #
+      # @param [AbstractMapper::AST::Node] node
+      #
+      # @return [AbstractMapper::Rules::Base]
+
+      # @private
+      def initialize(node)
+        @node = node
+        super
+      end
+
+    end # class Sole
+
+  end # class Rule
+
+end # class AbstractMapper

data/lib/abstract_mapper/settings.rb

@@ -36,57 +36,49 @@ class AbstractMapper
     #
     attr_reader :builder
 
-    # @!scope class
-    # @!method new(&block)
-    # Creates a domain-specific settings with commands and rules initialized
-    # from inside a block
+    # Initializes a domain-specific settings with commands and rules
+    # being set in the block.
     #
     # @param [Proc] block
     #
-    # @return [AbstractMapper::Settings]
-
-    # @private
-    def initialize(&block)
-      __set_rules__
-      __set_commands__
-      __configure__(&block)
-      __set_builder__
-      __set_optimizer__
+    # @yield the block with settings for commands and rules
+    #
+    def initialize(rules = Rules.new, commands = Commands.new, &block)
+      @rules    = rules
+      @commands = commands
+      configure(&block)
       IceNine.deep_freeze(self)
     end
 
+    # Returns a new class with rules and commands added from the block
+    # to the existing ones
+    #
+    # @return [AbstractMapper::Settings]
+    #
+    # @yield the block with settings for commands and rules
+    #
+    def update(&block)
+      self.class.new(rules, commands, &block)
+    end
+
     private
 
     def rule(value)
-      fn = Functions[:subclass?, Rule]
+      fn = Functions[:subclass?, Rules::Base]
       fail Errors::WrongRule.new(value) unless fn[value]
       @rules = rules << value
     end
 
     def command(name, node, &block)
-      fn = Functions[:subclass?, Node]
+      fn = Functions[:subclass?, AST::Node]
       fail Errors::WrongNode.new(node) unless fn[node]
       @commands = commands << [name, node, block]
     end
 
-    def __set_rules__
-      @rules = Rules.new
-    end
-
-    def __set_commands__
-      @commands = Commands.new
-    end
-
-    def __configure__(&block)
+    def configure(&block)
       instance_eval(&block) if block_given?
-    end
-
-    def __set_builder__
       @builder = Class.new(Builder)
       builder.commands = commands
-    end
-
-    def __set_optimizer__
       @optimizer = Optimizer.new(rules)
     end
 

data/lib/abstract_mapper/version.rb

@@ -4,6 +4,6 @@ class AbstractMapper
 
   # The semantic version of the module.
   # @see http://semver.org/ Semantic versioning 2.0
-  VERSION = "0.0.2".freeze
+  VERSION = "0.1.0".freeze
 
 end # class AbstractMapper

data/lib/rspec/nodes.rb

@@ -20,7 +20,7 @@ shared_examples :creating_immutable_node do
 
   subject { node }
 
-  it { is_expected.to be_kind_of AbstractMapper::Node }
+  it { is_expected.to be_kind_of AbstractMapper::AST::Node }
   it { is_expected.to be_frozen, "expected #{subject.inspect} to be immutable" }
 
 end # shared examples
@@ -31,7 +31,7 @@ shared_examples :creating_immutable_branch do
 
   subject { node }
 
-  it { is_expected.to be_kind_of AbstractMapper::Branch }
+  it { is_expected.to be_kind_of AbstractMapper::AST::Branch }
   it { is_expected.to be_frozen, "expected #{subject.inspect} to be immutable" }
 
 end # shared examples

data/spec/integration/faceter.rb

@@ -14,13 +14,13 @@ shared_context "Faceter" do
       end
 
       # Nodes
-      class List < AbstractMapper::Branch
+      class List < AbstractMapper::AST::Branch
         def transproc
           Functions[:map_array, super]
         end
       end
 
-      class Rename < AbstractMapper::Node
+      class Rename < AbstractMapper::AST::Node
         attribute :keys
 
         def transproc
@@ -29,7 +29,7 @@ shared_context "Faceter" do
       end
 
       # Rules
-      class CompactLists < AbstractMapper::PairRule
+      class CompactLists < AbstractMapper::Rules::Pair
         def optimize?
           left.is_a?(List) && right.is_a?(List)
         end
@@ -39,7 +39,7 @@ shared_context "Faceter" do
         end
       end
 
-      class CompactRenames < AbstractMapper::PairRule
+      class CompactRenames < AbstractMapper::Rules::Pair
         def optimize?
           left.is_a?(Rename) && right.is_a?(Rename)
         end