abstract_mapper 0.0.2 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0547716c6b580abf30fd1b16d2e42cb2656971da
-  data.tar.gz: 7c793b44bebc3157b32cb754e76fd8e7c550a242
+  metadata.gz: a20fe042523fd0d4f3e37d3838e4e3a4c3770950
+  data.tar.gz: a3fe86965e9a2c223023a0fa447680d677d771d1
 SHA512:
-  metadata.gz: 89772b4b3618585644e6224b93abd13276d1ed057be038ce38c677b752aefacc424fa3d05076810555afe976a45d4e059c82eb96cb7acc2b9f29b96fa66c7f15
-  data.tar.gz: 688f0f055d98a12c7558948b5191c9f1e7fe0d43ac740929339fb3a1e7a700252273a535430c21d3676ecf229ba61257661890711a343f333c66bc9fdce2da5a
+  metadata.gz: fb3864254189282a0a0be1da50905c803cf4d8009c6b17893a74b3d262fe4ab5ec885687a61ce801ccf75100e7212c1515dc8eab91e0c91ec372c00292e3692b
+  data.tar.gz: 673c8268699b47ec511d63326b7aea6226115f50741137f8fdcff905f6d03fc89a86db52355eabb1e0482b1e06a6bda9d05b311f98407e25ff55861496a16580

data/.travis.yml

@@ -4,14 +4,10 @@ cache:        bundler
 script:       "bundle exec rake test:coverage:run"
 bundler_args: --without metrics
 rvm:
-  - '1.9.3'
-  - '2.0'
   - '2.1'
   - '2.2'
   - ruby-head
-  - rbx-2 --1.9
   - rbx-2 --2.1
-  - jruby-19mode
   - jruby-20mode
   - jruby-head
 matrix:

data/CHANGELOG.md

@@ -1,3 +1,29 @@
+## v0.1.0 2015-09-18
+
+This version rearranges some classes by adding namespaces and **extends the behaviour of configure**.
+With a new support pre-defined mappers can be inherited deeply with updated set of commands and rules.
+
+### Added
+
+* `AbstractMapper.configure` now updates the existing settings instead of rewriting them from scratch (nepalez)
+   with reference to issue #1 (faceter#2 by martinciu)
+
+### Changed (backward incompatible!)
+
+* Rules and Nodes were namespaces and renamed (nepalez):
+  - `AbstractMapper::Node`     -> `AbstractMapper::AST::Node`
+  - `AbstractMapper::Branch`   -> `AbstractMapper::AST::Branch`
+  - `AbstractMapper::Rule`     -> `AbstractMapper::Rules::Base`
+  - `AbstractMapper::SoleRule` -> `AbstractMapper::Rules::Sole`
+  - `AbstractMapper::PairRule` -> `AbstractMapper::Rules::Pair`
+
+### Internal
+
+* Extracted `Attributes` to the external gem 'attributes_dsl' (nepalez)
+* Renamed `Command` to `Commands::Base` (nepalez)
+
+[Compare v0.0.2...v0.1.0](https://github.com/nepalez/abstract_mapper/compare/v0.0.2...v0.1.0)
+
 ## v0.0.2 2015-08-06
 
 ### Added

data/README.md

@@ -94,19 +94,19 @@ end
 
 ### Define optimization rules
 
-AbstractMapper defines 2 rules `AbstractMapper::SoleRule` and `AbstractMapper::PairRule`. The first one is applicable to every single node to check if it can be optimized by itself, the second one takes two consecutive nodes and either return them unchanged, or merges them into more time-efficient node.
+AbstractMapper defines 2 rules `AbstractMapper::Rules::Sole` and `AbstractMapper::Rules::Pair`. The first one is applicable to every single node to check if it can be optimized by itself, the second one takes two consecutive nodes and either return them unchanged, or merges them into more time-efficient node.
 
 For every rule you need to define two methods:
 
 * `#optimize?` that defines if the rule is applicable to given node (or pair of nodes)
 * `#optimize` that returns either array of changed nodes, or one node, or nothing when the node(s) should be removed from the tree
 
-Use `#nodes` method to access nodes to be optimized. Base class `AbstractMapper::SoleRule` also defines the `#node` method, while `AbstractMapper::PairRule` defines `#left` and `#right` for the corresponding parts of the pair.
+Use `#nodes` method to access nodes to be optimized. Base class `AbstractMapper::Rules::Sole` also defines the `#node` method, while `AbstractMapper::Rules::Pair` defines `#left` and `#right` for the corresponding parts of the pair.
 
 ```ruby
 module Faceter
   # The empty lists are useless, because they does nothing at all
-  class RemoveEmptyLists < AbstractMapper::SoleRule
+  class RemoveEmptyLists < AbstractMapper::Rules::Sole
     def optimize?
       node.is_a?(List) && node.empty?
     end
@@ -121,7 +121,7 @@ module Faceter
   #
   # That's why when we meet two consecutive lists, we have to merge them
   # into the one list, containing subnodes (entries) from both sources.
-  class CompactLists < AbstractMapper::PairRule
+  class CompactLists < AbstractMapper::Rules::Pair
     def optimize?
       nodes.map { |n| n.is_a? List }.reduce(:&)
     end
@@ -132,7 +132,7 @@ module Faceter
   end
 
   # Two consecutive renames can be merged
-  class CompactRenames < AbstractMapper::PairRule
+  class CompactRenames < AbstractMapper::Rules::Pair
     def optimize?
       nodes.map { |n| n.is_a? Rename }.reduce(:&)
     end

data/Rakefile

@@ -15,7 +15,7 @@ rescue LoadError
   Hexx::RSpec.install_tasks
 end
 
-# Sets the Hexx::RSpec :test task to default
+desc "Sets the Hexx::RSpec :test task to default"
 task :default do
   system "bundle exec rake test:coverage:run"
 end

data/abstract_mapper.gemspec

@@ -19,6 +19,7 @@ Gem::Specification.new do |gem|
 
   gem.required_ruby_version = ">= 2.1"
 
+  gem.add_runtime_dependency "attributes_dsl", "~> 0.0"
   gem.add_runtime_dependency "ice_nine", "~> 0.11"
   gem.add_runtime_dependency "transproc", "~> 0.3", ">= 0.3.1"
 

data/lib/abstract_mapper.rb

@@ -1,27 +1,16 @@
 # encoding: utf-8
 
+require "attributes_dsl"
 require "ice_nine"
 require "transproc"
 
 require_relative "abstract_mapper/functions"
-
-require_relative "abstract_mapper/errors/unknown_command"
-require_relative "abstract_mapper/errors/wrong_node"
-require_relative "abstract_mapper/errors/wrong_rule"
-
-require_relative "abstract_mapper/attributes"
-require_relative "abstract_mapper/node"
-require_relative "abstract_mapper/branch"
-require_relative "abstract_mapper/command"
+require_relative "abstract_mapper/errors"
+require_relative "abstract_mapper/ast"
 require_relative "abstract_mapper/commands"
-require_relative "abstract_mapper/builder"
-
-require_relative "abstract_mapper/rule"
-require_relative "abstract_mapper/sole_rule"
-require_relative "abstract_mapper/pair_rule"
 require_relative "abstract_mapper/rules"
+require_relative "abstract_mapper/builder"
 require_relative "abstract_mapper/optimizer"
-
 require_relative "abstract_mapper/settings"
 require_relative "abstract_mapper/dsl"
 

data/lib/abstract_mapper/ast.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+class AbstractMapper
+
+  # The namespace for nodes of the abstract syntax tree
+  #
+  # @author Andrew Kozin <Andrew.Kozin@gmail.com>
+  #
+  module AST
+
+    require_relative "ast/node"
+    require_relative "ast/branch"
+
+  end # module AST
+
+end # class AbstractMapper

data/lib/abstract_mapper/ast/branch.rb

@@ -0,0 +1,121 @@
+# encoding: utf-8
+
+class AbstractMapper
+
+  module AST
+
+    # A special type of the composed node, that describes transformation,
+    # applied to some level of nested input.
+    #
+    # Unlike the simple node, describing a transformation of data, the
+    # branch carries a collection of subnodes along with methods to [#update]
+    # itself with the same attributes and different subnodes.
+    #
+    # Tne branch only stores subnodes and composes transformations.
+    # Its has no access to DSL and knows neither how to build a tree
+    # (see [AbstractMapper::Builder]), nor how to optimize it later
+    # (see [AbstractMapper::Optimizer]).
+    #
+    # @api public
+    #
+    class Branch < Node
+
+      include Enumerable
+
+      # @!scope class
+      # @!method new(*attributes, &block)
+      # Creates a new branch
+      #
+      # @param [Object, Array<Object>] attributes
+      #   The list of type-specific attributes of the branch
+      # @param [Proc] block
+      #   The block that returns an array of subnodes for the branch
+      #
+      # @return [Branch::AST::Node]
+
+      # @private
+      def initialize(attributes = {})
+        @subnodes = block_given? ? yield : []
+        super(attributes, &nil)
+      end
+
+      # Returns a new branch of the same type, with the same attributes,
+      # but with a different collection of subnodes, transmitted by the block.
+      #
+      # @example
+      #   branch = Branch.new(:foo)
+      #   # => <Branch(:foo) []>
+      #   branch.update { AST::Node.new(:bar) }
+      #   # => <Branch(:foo) [<AST::Node(:bar)>]>
+      #
+      # @return [AbstractMapper::Branch]
+      #
+      # @yield block
+      #
+      def update
+        self.class.new(attributes) { yield }
+      end
+
+      # @!method each
+      # Returns the enumerator for subnodes
+      #
+      # @return [Enumerator]
+      #
+      def each(&block)
+        @subnodes.each(&block)
+      end
+
+      # Returns a new branch with the other node added to its subnodes
+      #
+      # @param [AbstractMapper::AST::Node] other
+      #
+      # @return [AbstractMapper::Branch]
+      #
+      def <<(other)
+        update { entries << other }
+      end
+
+      # The composition of transformations from all subnodes of the branch
+      #
+      # To be reloaded by the subclasses to apply the composition to
+      # a corresponding level of nested data.
+      #
+      # @return [Transproc::Function]
+      #
+      # @abstract
+      #
+      def transproc
+        map(&:transproc).inject(:>>)
+      end
+
+      # Adds subnodes to the default description of the branch
+      #
+      # @return [String]
+      #
+      def to_s
+        "#{super} [#{map(&:inspect).join(", ")}]"
+      end
+
+      # Checks equality of branches by type, attributes and subnodes
+      #
+      # @param [Other] other
+      #
+      # @return [Boolean]
+      #
+      def eql?(other)
+        super && entries.eql?(other.entries)
+      end
+
+      private
+
+      # Substitutes the name of the class by the special name "Root"
+      # to describe the root node of AST.
+      def __name__
+        instance_of?(Branch) ? "Root" : super
+      end
+
+    end # class Branch
+
+  end # module AST
+
+end # class AbstractMapper

data/lib/abstract_mapper/ast/node.rb

@@ -0,0 +1,91 @@
+# encoding: utf-8
+
+class AbstractMapper
+
+  module AST
+
+    # An immutable node of the abstract syntax tree (AST), that describes
+    # either some "end-up" transformation, or a level of nested input data.
+    #
+    # Every node is expected to accept attributes and (possibly) block, and
+    # implement `#transproc` that implements the `#call` method to
+    # transform input data to the output.
+    #
+    # AST::Nodes describe only the structure of AST, they know
+    # neither how to build the tree with DSL (see [AbstractMapper::Builder]),
+    # nor how to optimize it later (see [AbstractMapper::Optimizer]).
+    #
+    # @api public
+    #
+    class AST::Node
+
+      extend AttributesDSL
+      include Comparable
+
+      # @!attribute [r] block
+      #
+      # @return [Proc] The block given to initializer
+      #
+      attr_reader :block
+
+      # @private
+      def initialize(_ = {}, &block)
+        super
+        @block = block
+        IceNine.deep_freeze(self)
+      end
+
+      # @!method transproc
+      # The transformation function for the branch
+      #
+      # @return [Transproc::Function]
+      #
+      # @abstract
+      #
+      def transproc
+        Functions[:identity]
+      end
+
+      # Returns a human-readable string representating the node
+      #
+      # @return [String]
+      #
+      def inspect
+        "<#{self}>"
+      end
+
+      # Converts the node into string with its name and attributes
+      #
+      # @return [String]
+      #
+      def to_s
+        "#{__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__
+        self.class.name.split("::").last
+      end
+
+      def __attributes__
+        return if attributes.empty?
+        "(#{attributes.map { |k, v| "#{k}: #{v.inspect}" }.join(", ")})"
+      end
+
+    end # class AST::Node
+
+  end # module AST
+
+end # class AbstractMapper

data/lib/abstract_mapper/builder.rb

@@ -39,7 +39,7 @@ class AbstractMapper
     #
     # @return (see #tree)
     #
-    def self.update(node = Branch.new, &block)
+    def self.update(node = AST::Branch.new, &block)
       new(node, &block).tree
     end
 
@@ -72,7 +72,7 @@ class AbstractMapper
 
     def method_missing(name, *args, &block)
       node  = @commands[name].call(*args, &block)
-      @tree = tree << (node.is_a?(Branch) ? update(node, &block) : node)
+      @tree = tree << (node.is_a?(AST::Branch) ? update(node, &block) : node)
     end
 
     def respond_to_missing?(*)

data/lib/abstract_mapper/commands.rb

@@ -2,6 +2,8 @@
 
 class AbstractMapper
 
+  require_relative "commands/base"
+
   # Collection of DSL commands used by the builder
   #
   # @api private
@@ -29,7 +31,7 @@ class AbstractMapper
     # @return [undefined]
     #
     def <<(other)
-      command = Command.new(*other)
+      command = Base.new(*other)
       self.class.new @registry.merge(command.name => command)
     end
 
@@ -37,7 +39,7 @@ class AbstractMapper
     #
     # @param [#to_sym] name The name of the command
     #
-    # @return [AbstractMapper::Command]
+    # @return [AbstractMapper::Commands::Base]
     #
     # @raise [AbstractMapper::Errors::UnknownCommand]
     #   When unknown command is called

data/lib/abstract_mapper/commands/base.rb

@@ -0,0 +1,69 @@
+# encoding: utf-8
+
+class AbstractMapper
+
+  class Commands
+
+    # Describes the command of the mapper
+    #
+    # Method `#call` builds a correspodning node for the AST.
+    #
+    # @api private
+    #
+    class Base
+
+      # @!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::Commands::Base]
+
+      # @private
+      def initialize(name, klass, converter = nil)
+        @name = name.to_sym
+        @klass = klass
+        @branch = Functions[:subclass?, AST::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
+      # @param [Proc] block
+      #
+      # @return [AbstractMapper::AST::Node]
+      #
+      def call(*args, &block)
+        block = nil if @branch
+        klass.new(converter.call(*args), &block)
+      end
+
+    end # class Base
+
+  end # class Commands
+
+end # class AbstractMapper