rosette-core 1.0.1

data/lib/rosette/core/path_matcher_factory.rb

@@ -0,0 +1,330 @@
+# encoding: UTF-8
+
+module Rosette
+  module Core
+    # Constructs condition trees for path matchers.
+    #
+    # @see ExtractorConfig
+    class PathMatcherFactory
+      # Creates a new empty node that can be used as the root of a
+      # conditions tree.
+      #
+      # @return [Node] the new empty node
+      def self.create_root
+        Node.new
+      end
+
+      # Facilitates creating operator nodes that can perform binary
+      # operations, like "and", "or", and "not".
+      module NodeOperatorFactory
+        # Creates an {OrNode} for combining two nodes together with a
+        # logical "or".
+        #
+        # @param [Node] right The other node. The left node is +self+.
+        # @return [OrNode] a node representing the logical "or" of +self+
+        #   and +right+.
+        def or(right)
+          OrNode.new(self, right)
+        end
+
+        # Creates an {AndNode} for combining two nodes together with a
+        # logical "and".
+        #
+        # @param [Node] right The other node. The left node is +self+.
+        # @return [AndNode] a node representing the logical "and" of +self+
+        #   and +right+.
+        def and(right)
+          AndNode.new(self, right)
+        end
+
+        # Creates a {NotNode} for negating +self+.
+        #
+        # @return [NotNode] a node representing the negation of +self+.
+        def not
+          NotNode.new(self)
+        end
+      end
+
+      # Provides common methods for creating nodes.
+      module NodeFactory
+        # Creates a {FileExtensionNode}.
+        #
+        # @param [String] extension The file extension to match.
+        # @return [FileExtensionNode]
+        def match_file_extension(extension)
+          FileExtensionNode.new(extension)
+        end
+
+        # Creates a bunch of {FileExtensionNode}s combined using a logical "or".
+        #
+        # @param [Array<String>] extensions A list of file extensions.
+        # @return [FileExtensionNode, OrNode] the root node of a tree of all
+        #   the file extensions specified in +extensions+. Each file extension
+        #   will be wrapped in a {FileExtensionNode} and logically "or"ed
+        #   together. If +extensions+ only contains one file extension, then this
+        #   method just returns an instance of {FileExtensionNode}. If +extensions+
+        #   contains more than one entry, this method returns an {OrNode}.
+        def match_file_extensions(extensions)
+          Array(extensions).inject(nil) do |node, extension|
+            new_node = match_file_extension(extension)
+            node ? node.or(new_node) : new_node
+          end
+        end
+
+        # Creates a {PathNode}.
+        #
+        # @param [String] path The path to match.
+        # @return [PathNode]
+        def match_path(path)
+          PathNode.new(path)
+        end
+
+        # Creates a bunch of {PathNode}s combined using a logical "or".
+        #
+        # @param [Array<String>] paths A list of paths.
+        # @return [PathNode, OrNode] the root of a tree of all the paths specified
+        #   in +paths+. Each path will be wrapped in a {PathNode} and logically
+        #   "or"ed together. If +paths+ only contains one path, then this method
+        #   just returns an instance of {PathNode}. If +paths+ contains more than
+        #   one entry, this method returns an {OrNode}.
+        def match_paths(paths)
+          Array(paths).inject(nil) do |node, path|
+            new_node = match_path(path)
+            node ? node.or(new_node) : new_node
+          end
+        end
+
+        # Creates a {RegexNode}.
+        #
+        # @param [Regexp] regex The regex to match.
+        # @return [RegexNode]
+        def match_regex(regex)
+          RegexNode.new(regex)
+        end
+
+        # Creates a bunch of {RegexNode}s combined using a logical "or".
+        #
+        # @param [Array<Regexp>] regexes A list of regular expressions.
+        # @return [RegexNode, OrNode] the root of a tree of all the regexes specified
+        #   in +regexes+. Each regex will be wrapped in a {RegexNode} and logically
+        #   "or"ed together. If +regexes+ only contains one entry, then this method
+        #   just returns an instance of {RegexNode}. If +regexes+ contains more than
+        #   one entry, this method returns an {OrNode}.
+        def match_regexes(regexes)
+          Array(regexes).inject(nil) do |node, regex|
+            new_node = match_regex(regex)
+            node ? node.or(new_node) : new_node
+          end
+        end
+      end
+
+      include NodeFactory
+
+      # The base class for all condition nodes.
+      class Node
+        include NodeFactory
+        include NodeOperatorFactory
+
+        # Determines if the given path matches the conditions defined by this node
+        # and it's children.
+        #
+        # @param [String] path The path to match.
+        # @return [Boolean] true if +path+ matches, false otherwise.
+        def matches?(path)
+          false
+        end
+      end
+
+      # The base class for all nodes that perform binary operations (i.e.
+      # operations that take two operands).
+      #
+      # @!attribute [r] left
+      #   @return [Node] the left child.
+      # @!attribute [r] right
+      #   @return [Node] the right child.
+      class BinaryNode < Node
+        attr_reader :left, :right
+
+        # Creates a new binary node with left and right children.
+        #
+        # @param [Node] left The left child.
+        # @param [Node] right The right child.
+        def initialize(left, right)
+          @left = left
+          @right = right
+        end
+      end
+
+      # The base class for all nodes that perform unary operations (i.e.
+      # operations that take only one operand).
+      #
+      # @!attribute [r] child
+      #   @return [Node] the child node.
+      class UnaryNode < Node
+        attr_reader :child
+
+        # Creates a new unary node.
+        #
+        # @param [Node] child The child.
+        def initialize(child)
+          @child = child
+        end
+      end
+
+      # A logical "and".
+      class AndNode < BinaryNode
+        # Determines if the given path matches the left AND the right child's
+        # conditions.
+        #
+        # @param [String] path The path to match.
+        # @return [Boolean] true if both the left and right children match
+        #   +path+, false otherwise.
+        def matches?(path)
+          left.matches?(path) && right.matches?(path)
+        end
+
+        # Generates a string representation of this node.
+        #
+        # @return [String]
+        def to_s
+          "(#{left.to_s} AND #{right.to_s})"
+        end
+      end
+
+      # A logical "OR".
+      class OrNode < BinaryNode
+        # Determines if the given path matches the left OR the right child's
+        # conditions.
+        #
+        # @param [String] path The path to match.
+        # @return [Boolean] true if the left or the right child matches +path+,
+        #   false otherwise.
+        def matches?(path)
+          left.matches?(path) || right.matches?(path)
+        end
+
+        # Generates a string representation of this node.
+        #
+        # @return [String]
+        def to_s
+          "(#{left.to_s} OR #{right.to_s})"
+        end
+      end
+
+      # A logical "NOT".
+      class NotNode < UnaryNode
+        # Determines if the given path does NOT match the child's conditions.
+        #
+        # @param [String] path The path to match.
+        # @return [Boolean] true if the child does not match +path+, false
+        #   otherwise.
+        def matches?(path)
+          !child.matches?(path)
+        end
+
+        # Generates a string representation of this node.
+        #
+        # @return [String]
+        def to_s
+          "(NOT #{child.to_s})"
+        end
+      end
+
+      # Matches file extensions.
+      #
+      # @!attribute [r] extension
+      #   @return [String] the extension to match.
+      class FileExtensionNode < Node
+        attr_reader :extension
+
+        # Creates a new file extension node.
+        #
+        # @param [String] extension The extension to match.
+        def initialize(extension)
+          @extension = extension
+        end
+
+        # Determines if the given path's file extension matches +extension+.
+        #
+        # @param [String] path The path to match.
+        # @return [Boolean] true if the path matches +extension+, false otherwise.
+        def matches?(path)
+          # avoid using File.extname to allow matching against double extensions,
+          # eg. file.html.erb
+          path[-extension.size..-1] == extension
+        end
+
+        # Generates a string representation of this node.
+        #
+        # @return [String]
+        def to_s
+          "has_file_extension('#{extension}')"
+        end
+      end
+
+      # Matches paths.
+      #
+      # @!attribute [r] path
+      #   @return [String] the path to match.
+      class PathNode < Node
+        attr_reader :path
+
+        # Creates a new path node.
+        #
+        # @param [String] path The path to match.
+        def initialize(path)
+          @path = path
+        end
+
+        # Determines if the given path matches +path+.
+        #
+        # @param [String] match_path The path to match.
+        # @return [Boolean] true if +match_path+ matches +path+, false otherwise.
+        #   Matching is done by comparing the first +n+ characters of +match_path+
+        #   to +path+, where +n+ is the number of characters in +path+. In other words,
+        #   if +path+ is "/path/to" and +match_path+ is '/path/to/foo.rb', this method
+        #   will return true.
+        def matches?(match_path)
+          match_path[0...path.size] == path
+        end
+
+        # Generates a string representation of this node.
+        #
+        # @return [String]
+        def to_s
+          "matches_path('#{path}')"
+        end
+      end
+
+      # Determines if the given path matches +regex+.
+      #
+      # @!attribute [r] regex
+      #   @return [Regex] The regex to match with.
+      class RegexNode < Node
+        attr_reader :regex
+
+        # Creates a new regex node.
+        #
+        # @param [Regex] regex The regex to match with.
+        def initialize(regex)
+          @regex = regex
+        end
+
+        # Determines if +regex+ matches the given path.
+        #
+        # @param [String] path The path to match.
+        # @return [Boolean] true if +regex+ matches +path+, false otherwise.
+        def matches?(path)
+          !!(path =~ regex)
+        end
+
+        # Generates a string representation of this node.
+        #
+        # @return [String]
+        def to_s
+          "matches_regex(/#{regex.source}/)"
+        end
+      end
+    end
+  end
+end

data/lib/rosette/core/resolvers/extractor_id.rb

@@ -0,0 +1,37 @@
+# encoding: UTF-8
+
+module Rosette
+  module Core
+
+    # Logic for handling extractor ids. Extractor ids are strings that refer to
+    # a particular extractor class. For example, the id 'yaml/rails' refers to
+    # +Rosette::Extractors::YamlExtractor::RailsExtractor+.
+    #
+    # @example
+    #   ExtractorId.resolve('yaml/rails')
+    #   # => Rosette::Extractors::YamlExtractor::RailsExtractor
+    class ExtractorId < Resolver
+      class << self
+
+        # Parses and identifies the class constant for the given extractor id.
+        #
+        # @param [Class, String] extractor_id When given a class, returns the
+        #   class. When given a string, parses and identifies the corresponding
+        #   class constant in +namespace+.
+        # @param [Class] namespace The namespace to look in.
+        # @return [Class] The identified class constant.
+        def resolve(extractor_id, namespace = Rosette::Extractors)
+          super
+        end
+
+        private
+
+        def suffix
+          'Extractor'
+        end
+
+      end
+    end
+
+  end
+end

data/lib/rosette/core/resolvers/integration_id.rb

@@ -0,0 +1,37 @@
+# encoding: UTF-8
+
+module Rosette
+  module Core
+
+    # Logic for handling integration ids. Integration ids are strings that refer
+    # to a particular integration class. For example, the id 'smartling' refers
+    # to +Rosette::Integrations::SmartlingIntegration+.
+    #
+    # @example
+    #   IntegrationId.resolve('smartling')
+    #   # => Rosette::Integrations::SmartlingIntegration
+    class IntegrationId < Resolver
+      class << self
+
+        # Parses and identifies the class constant for the given integration id.
+        #
+        # @param [Class, String] integration_id When given a class, returns the
+        #   class. When given a string, parses and identifies the corresponding
+        #   class constant in +namespace+.
+        # @param [Class] namespace The namespace to look in.
+        # @return [Class] The identified class constant.
+        def resolve(integration_id, namespace = Rosette::Integrations)
+          super
+        end
+
+        private
+
+        def suffix
+          'Integration'
+        end
+
+      end
+    end
+
+  end
+end

data/lib/rosette/core/resolvers/preprocessor_id.rb

@@ -0,0 +1,38 @@
+# encoding: UTF-8
+
+module Rosette
+  module Core
+
+    # Logic for handling preprocessor ids. Preprocessor ids are strings that
+    # refer to a particular preprocessor class. For example, the id
+    # 'normalization' refers to
+    # +Rosette::Preprocessors::NormalizationPreprocessor+.
+    #
+    # @example
+    #   PreprocessorId.resolve('normalization')
+    #   # => Rosette::Preprocessors::NormalizationPreprocessor
+    class PreprocessorId < Resolver
+      class << self
+
+        # Parses and identifies the class constant for the given preprocessor id.
+        #
+        # @param [Class, String] preprocessor_id When given a class, returns the
+        #   class. When given a string, parses and identifies the corresponding
+        #   class constant in +namespace+.
+        # @param [Class] namespace The namespace to look in.
+        # @return [Class] The identified class constant.
+        def resolve(preprocessor_id, namespace = Rosette::Preprocessors)
+          super
+        end
+
+        private
+
+        def suffix
+          'Preprocessor'
+        end
+
+      end
+    end
+
+  end
+end

data/lib/rosette/core/resolvers/resolver.rb

@@ -0,0 +1,115 @@
+# encoding: UTF-8
+
+module Rosette
+  module Core
+
+    # Base class for Rosette's id resolvers that can look up a class constant
+    # given a namespaced id (string separated by forward slashes). For example,
+    # the extractor id "yaml/rails" resolves to
+    # +Rosette::Extractors::YamlExtractor::RailsExtractor+.
+    #
+    # @example
+    #   class MyResolver < Resolver
+    #     def resolve(id, namespace = MyNamespace::Foo)
+    #       super
+    #     end
+    #
+    #     private
+    #
+    #     # Must be defined by classes that inherit from Resolver.
+    #     def suffix
+    #       'Stuff'
+    #     end
+    #   end
+    #
+    #   module MyNamespace
+    #     module Foo
+    #       module BarStuff
+    #         class BazStuff
+    #           ...
+    #         end
+    #       end
+    #     end
+    #   end
+    #
+    #   MyResolver.resolve('bar/baz')  # => MyNamespace::Foo::BarStuff::BazStuff
+    class Resolver
+      class << self
+
+        # Parses and identifies the class constant for the given id.
+        #
+        # @param [Class, String] id When given a class, returns the class. When
+        #   given a string, parses and identifies the corresponding class
+        #   constant in +namespace+.
+        # @param [Class] namespace The namespace to look in.
+        # @return [Class] The identified class constant.
+        def resolve(id, namespace)
+          klass = case id
+            when Class
+              id
+            when String
+              lookup(id, namespace)
+          end
+
+          unless klass
+            raise ArgumentError, "#{id} could not be found - have you required it?"
+          end
+
+          klass
+        end
+
+        # Splits an id into parts.
+        #
+        # @param [String] id The id to parse.
+        # @return [Array<String>] A list of id parts.
+        def parse_id(id)
+          id.split('/')
+        end
+
+        private
+
+        def lookup(id, namespace)
+          find_const(
+            const_candidates(
+              parse_id(id).map do |segment|
+                StringUtils.camelize(segment)
+              end
+            ), namespace
+          )
+        end
+
+        # Appends the suffix to each segment one at a time and returns intermediate
+        # arrays of segments. For example, if given ['Json', 'KeyValue'] and a suffix
+        # of 'Serializer', this method would return:
+        # [['Json', 'KeyValue'], ['Json', 'KeyValueSerializer'], ['JsonSerializer', 'KeyValueSerializer']]
+        def const_candidates(segments)
+          [segments] + segments.map.with_index do |segment, idx|
+            candidate = segments[0...(segments.size - (idx + 1))]
+            candidate + segments[(segments.size - (idx + 1))..-1].map do |sub_seg|
+              "#{sub_seg}#{suffix}"
+            end
+          end
+        end
+
+        def suffix
+          raise NotImplementedError, "#{__method__} must be defined in derived classes"
+        end
+
+        def find_const(candidates, namespace)
+          candidates.each do |segments|
+            found_const = segments.inject(namespace) do |const, segment|
+              if const && const.const_defined?(segment)
+                const.const_get(segment)
+              end
+            end
+
+            return found_const if found_const
+          end
+          nil
+        end
+
+      end
+    end
+
+  end
+end