mantra 0.1.0 → 0.2.0

data/lib/mantra/helpers/object_with_type.rb

@@ -0,0 +1,60 @@
+module Mantra
+  module Helpers
+    module ObjectWithType
+
+      class UnknownType < Exception; end
+      class UnspecifiedType < Exception; end
+
+      def self.included(base)
+        base.send :extend, ClassMethods
+        base.send :include, InstanceMethods
+      end
+
+      module ClassMethods
+        def type(type=nil)
+          type.nil? ? @type : (@type = type.to_sym)
+        end
+
+        def alias_type(alias_type=nil)
+          alias_type.nil? ? @alias_type : (@alias_type = alias_type.to_sym)
+        end
+
+        def create(options)
+          type = options[:type] || options["type"]
+          raise UnspecifiedType.new("options hash should contain type") if type.nil?
+          subclass = self.find_by_type(type.to_sym)
+          if subclass.nil?
+            raise UnknownType.new("unknown type #{type}")
+          else
+            subclass.new(options)
+          end
+        end
+
+        def find_by_type(type)
+          self.subclasses.find { |s| s.type == type || s.alias_type == type }
+        end
+
+        def inherited(subclass)
+          subclasses << subclass
+          super
+        end
+
+        def subclasses
+          @subclasses ||= []
+        end
+      end
+
+      module InstanceMethods
+        def type
+          self.class.type
+        end
+
+        attr_accessor :options
+
+        def initialize(options={})
+          @options = options
+        end
+      end
+    end
+  end
+end

data/lib/mantra/helpers/regexp_helper.rb

@@ -0,0 +1,12 @@
+module Mantra
+  module Helpers
+    module RegexpHelper
+
+      def to_regexp(string)
+        escaped_string = Regexp.escape(string)
+        Regexp.new("^#{escaped_string.gsub("\\*", ".+")}$")
+      end
+
+    end
+  end
+end

data/lib/mantra/helpers/template_helper.rb

@@ -0,0 +1,70 @@
+class IpAddressTemplate
+  class Scope < String
+    attr_accessor :scope, :value
+    def initialize(options)
+      @value = options[:value]
+      @scope = options[:scope]
+      super(options[:scope])
+    end
+    def is_scope?
+      true
+    end
+  end
+
+  class Value < String
+    def is_scope?
+      false
+    end
+  end
+
+  attr_accessor :quads
+  def initialize(ip_address)
+    @quads = ip_address.split(".").map { |q| Value.new(q) }
+  end
+
+  def replace_with_scope(range, scope)
+    range.to_a.each do |i|
+      @quads[i] = Scope.new(scope: scope, value: @quads[i])
+    end
+  end
+
+  alias_method :replace_quad_range_with_scope, :replace_with_scope
+
+  def parts
+    result = [@quads.first]
+    @quads[1..-1].each do |q|
+      if q.is_scope? && result.last.is_scope? && q.scope == result.last.scope
+        result.last.value = [result.last.value, q.value].join(".")
+      else
+        result << Value.new(".") << q
+      end
+    end
+    result
+  end
+end
+
+module Mantra
+  module Helpers
+    module TemplateHelper
+
+      def is_scope?(v)
+        v.respond_to?(:is_scope?) && v.is_scope?
+      end
+
+      def templatize(parts)
+        merged_parts = [parts.shift]
+        parts.each do |p|
+          if !is_scope?(p) && !is_scope?(merged_parts.last)
+            merged_parts.last.concat(p)
+          else
+            merged_parts << p
+          end
+        end
+        merged_parts.select { |p| !p.empty? }.map do |p|
+          is_scope?(p) ? p : "\"#{p}\""
+        end
+      end
+
+    end
+  end
+end

data/lib/mantra/manifest/array_element.rb

@@ -0,0 +1,84 @@
+module Mantra
+  class Manifest
+    class ArrayElement < Element
+
+      type :array
+
+      def content=(content)
+        @content = content.map do |item|
+          Element.create(item, self)
+        end
+      end
+
+      def merge(element, options={})
+        raise merge_conflict_error(element) unless self.can_merge?(element)
+        elements_to_add = element.content.dup
+        merge_by_name(elements_to_add, options)
+        merge_by_value(elements_to_add, options)
+        self.content.concat(elements_to_add)
+        self
+      end
+
+      def find_children_by_scope(scope)
+        return [] unless scope.array?
+        self.content.map do |element|
+          if scope.match?(element)
+            if scope.has_next?
+              element.find_children_by_scope(scope.next)
+            else
+              element
+            end
+          end
+        end.flatten.compact
+      end
+
+      def each(path, &block)
+        elements = select(path)
+        elements.each(&block)
+      end
+
+      def selector_for(element)
+        self.content.index(element).to_s
+      end
+
+      def merge_by_value(elements, options={})
+        self.content.each do |self_element|
+          element_with_the_same_value = elements.find do |element_to_add|
+            self_element.content == element_to_add.content
+          end
+          unless element_with_the_same_value.nil?
+            self_element.merge(element_with_the_same_value, options)
+            elements.delete(element_with_the_same_value)
+          end
+        end
+      end
+
+      def children
+        self.content
+      end
+
+      def merge_by_name(elements, options={})
+        self.content.each do |self_element|
+          element_with_the_same_name = elements.find do |element_to_add|
+            self_element.has_equal_name?(element_to_add)
+          end
+          unless element_with_the_same_name.nil?
+            self_element.merge(element_with_the_same_name, options)
+            elements.delete(element_with_the_same_name)
+          end
+        end
+      end
+
+      def to_ruby_object
+        self.content.map { |element| element.to_ruby_object }
+      end
+
+      def traverse(&block)
+        self.content.each do |value|
+          value.traverse(&block)
+        end
+      end
+
+    end
+  end
+end

data/lib/mantra/manifest/element.rb

@@ -0,0 +1,175 @@
+module Mantra
+  class Manifest
+    class Element
+
+      class MergeConflictError < Exception; end
+      class UnknownScopeError  < Exception; end
+
+      include Helpers::ObjectWithType
+      include Helpers::RegexpHelper
+
+      attr_accessor :content, :parent
+
+      def self.create(content, parent = nil)
+        return RootElement.new(content, parent) if parent.nil?
+        case content
+        when Element then Element.create(content.content, parent)
+        when Array   then ArrayElement.new(content, parent)
+        when Hash    then HashElement.new(content, parent)
+        else LeafElement.new(content, parent)
+        end
+      end
+
+      def initialize(content, parent)
+        self.content = content
+        self.parent  = parent
+      end
+
+      # this method mimics ruby Hash#fetch method
+      def fetch(scope, &block)
+        current_scope = Scope.parse(scope)
+        element = self.root? ? self.content : self
+        current_scope.filter(element, &block)
+      end
+
+      alias_method :select, :fetch
+
+      def children
+        raise "not implemented"
+      end
+
+      def content=(content)
+        raise "#content=() method is not implemented"
+      end
+
+      def name
+        raise "unknown name"
+      end
+
+      def find(string_scope)
+        self.fetch(string_scope).first
+      end
+
+      def get(string_scope)
+        result = self.find(string_scope)
+        result.nil? ? nil : result.to_ruby_object
+      end
+
+      def has_name?
+        false
+      end
+
+      def has_equal_name?(element)
+        false
+      end
+
+      %i(leaf hash array root).each do |type|
+        define_method "#{type}?" do
+          self.type == type
+        end
+      end
+
+      def path
+        case self.parent.type
+        when :hash  then "#{self.parent.path}#{self.parent.parent.root? ? "" : "."}#{self.selector}"
+        when :array then "#{self.parent.path}[#{self.selector}]"
+        when :leaf  then raise "leaf can't be parent"
+        end
+      end
+
+      def selector
+        case self.parent.type
+        when :array
+          self.has_name? ? "name=#{self.name}" : ""
+        when :hash
+          self.parent.selector_for(self)
+        when :root
+          ""
+        else
+          raise "don't know how to build selector"
+        end
+      end
+
+      def merge(element, options={})
+        raise "not implemented"
+      end
+
+      def to_ruby_object
+        raise "not implemented"
+      end
+
+      def merge_conflict_error(element)
+        object = element.respond_to?(:to_ruby_object) ? element.to_ruby_object : element.inspect
+        MergeConflictError.new("merge conflicts: types: #{self.class} against #{element.class}, values:  #{self.to_ruby_object} with #{object}")
+      end
+
+      def can_merge?(element)
+        if element.respond_to?(:type)
+          self.type == element.type
+        else
+          self.class == element.class
+        end
+      end
+
+      def delete(selector)
+        raise "not implemented"
+      end
+
+      def method_missing(method_name, *arguments, &block)
+        if self.content.respond_to?(method_name)
+          self.content.send(method_name, *arguments, &block)
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        self.content.respond_to?(method_name) || super
+      end
+
+      def traverse(&block)
+        raise "not implemented"
+      end
+
+      def match_selector?(selector)
+        selector.empty?
+      end
+
+      def path_exist?(path)
+        !self.select(path).empty?
+      end
+
+      def add_node(selector, value)
+        raise "not implemented"
+      end
+
+      def self.element_with_selector(selector, value)
+        object_to_add = {}
+        parts = selector.split(".")
+        last_key = parts.pop
+        last_node = parts.inject(object_to_add) do |h, part|
+          h[part] = {}; h[part]
+        end
+        last_node[last_key] = value
+        Element.create(object_to_add)
+      end
+
+      def split_selector(selector, matcher_regex)
+        matcher = selector.match(matcher_regex)
+        raise UnknownScopeError.new("Unknown selector: #{selector}") if matcher.nil?
+        head_selector = matcher[1]
+        tail_selector = matcher[2]
+        return head_selector, tail_selector
+      end
+
+      def array_selector?(selector)
+        !!selector.match(/\[(.+\=.+|\d+)?\].*/)
+      end
+
+      def hash_selector?(selector)
+        !!selector.match(/[a-z0-9]+/)
+      end
+
+    end
+  end
+end

data/lib/mantra/manifest/ext.rb

@@ -0,0 +1,33 @@
+module Mantra
+  class Manifest
+    module Ext
+      def self.included(base)
+        base.send :extend, ClassMethods
+        base.send :include, InstanceMethods
+      end
+
+      module ClassMethods
+      end
+
+      module InstanceMethods
+
+        def properties
+          job_properties = Element.create({}).content
+          job_properties_array = self.jobs.map do |job|
+            job.hash? ? job.content["properties"] : nil
+          end.compact
+          job_properties_array.each do |jp|
+            job_properties.merge(jp)
+          end
+          manifest_properties = self.root.child.hash? ? self.root.child.content["properties"] : Element.create({}).content
+          manifest_properties.merge(job_properties)
+          Element.create(manifest_properties)
+        end
+
+        def jobs
+          self.root.content.hash? ? self.root.content.content["jobs"] : nil
+        end
+      end
+    end
+  end
+end

data/lib/mantra/manifest/hash_element.rb

@@ -0,0 +1,88 @@
+module Mantra
+  class Manifest
+    class HashElement < Element
+      type :hash
+
+      def content=(content) # content is hash
+        @content = content.to_a.inject({}) do |result, pair|
+          key, value = *pair
+          result[key] = Element.create(value, self)
+          result
+        end
+      end
+
+      def merge(element, options={})
+        raise merge_conflict_error(element) unless self.can_merge?(element)
+        self.content.merge!(element.content) do |_, self_element, element_to_merge|
+          self_element.merge(element_to_merge, options)
+        end
+        self
+      end
+
+      def to_ruby_object
+        self.content.to_a.inject({}) do |result, pair|
+          key, element = *pair
+          result[key] = element.to_ruby_object
+          result
+        end
+      end
+
+      def has_equal_name?(element)
+        self.has_name? && element.has_name? && self.name == element.name
+      end
+
+      def has_name?
+        self.content.has_key?("name")
+      end
+
+      def children
+        self.content.values
+      end
+
+      def name
+        raise "name should be a value, not node" if !self.content["name"].leaf?
+        self.content["name"].content || raise("no name for #{self.inspect}")
+      end
+
+      def selector_for(element)
+        self.content.each_pair do |key, value|
+          return key if value == element
+        end
+        raise "can't find key for object: #{element.to_ruby_object.inspect}"
+      end
+
+      def method_missing(method_name, *arguments, &block)
+        if self.content.has_key?(method_name.to_s) && arguments.empty?
+          self.content[method_name.to_s]
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        self.content.has_key?(method_name.to_s) || super
+      end
+
+      def traverse(&block)
+        self.content.each_value do |value|
+          value.traverse(&block)
+        end
+      end
+
+      def find_children_by_scope(scope)
+        return [] unless scope.hash?
+        self.content.each_pair.map do |pair|
+          key, value = *pair
+          if scope.match?(key, value)
+            if scope.has_next?
+              element.find_children_by_scope(scope.next)
+            else
+              element
+            end
+          end
+        end.flatten.compact
+      end
+
+    end
+  end
+end

data/lib/mantra/manifest/leaf_element.rb

@@ -0,0 +1,38 @@
+module Mantra
+  class Manifest
+    class LeafElement < Element
+
+      type :leaf
+
+      def content=(content)
+        @content = content
+      end
+
+      def merge(element, options={})
+        raise merge_conflict_error(element) unless self.can_merge?(element)
+        if !options[:force]
+          raise MergeConflictError.new("value conflict detected: #{self.content} != #{element.content}") if self.content != element.content
+        end
+        self
+      end
+
+      def to_ruby_object
+        self.content
+      end
+
+      def traverse(&block)
+        block.call(self)
+      end
+
+      def add_node(selector, value)
+        raise UnknownScopeError.new("Can't add nodes to leaf")  unless selector.empty?
+        raise MergeConflictError.new("Leaf already exists with another value: #{self.content} != #{value}") unless self.content != value
+      end
+
+      def children
+        []
+      end
+
+    end
+  end
+end

data/lib/mantra/manifest/root_element.rb

@@ -0,0 +1,38 @@
+module Mantra
+  class Manifest
+    class RootElement < Element
+
+      type :root
+
+      def content=(content)
+        @content = Element.create(content, self)
+      end
+
+      def path
+        ""
+      end
+
+      def merge(element, options={})
+        raise merge_conflict_error(element) unless self.can_merge?(element)
+        self.content.merge(element.content, options)
+      end
+
+      def to_ruby_object
+        self.content.to_ruby_object
+      end
+
+      def traverse(&block)
+        self.content.traverse(&block)
+      end
+
+      def child
+        self.content
+      end
+
+      def children
+        self.content
+      end
+
+    end
+  end
+end

data/lib/mantra/manifest/scope/array_scope.rb

@@ -0,0 +1,53 @@
+module Mantra
+  class Manifest
+    class Scope
+      class ArrayScope < Scope
+        class UnknownFunction < Exception; end
+
+        type :array
+
+        # returns array of children that are 
+        def _filter(element)
+          case scope
+          when /^\d+$/
+            index = scope.to_i
+            [element.content[index]]
+          when /^.+\=.+$/
+            key_wildcard, value_wildcard = scope.split("=")
+            key_matcher, value_matcher = to_regexp(key_wildcard), to_regexp(value_wildcard)
+            element.content.select { |e| e.hash? }.select do |e|
+              e.each_pair.any? do |pair|
+                k, v = *pair
+                k.match(key_matcher) && v.match(value_matcher)
+              end
+            end
+          when /^\:\:.+$/
+            function_name = self.scope[2..-1]
+            if !allowed_function_names.include?(function_name)
+              raise ScopeParseError.new("Unknown function: #{function_name}")
+            end
+            self.send(function_name, element)
+          when ""
+            element.content
+          else
+            raise ScopeParseError.new("Don't know how to apply scope to array " +
+                                      "(scope: #{self.scope.inspect}, array: #{element.to_ruby_object.inspect})")
+          end
+        end
+
+        def allowed_function_names
+          %w(last first)
+        end
+
+        def last(element)
+          [element.content.last]
+        end
+
+        def first(element)
+          [element.content.first]
+        end
+
+      end
+    end
+  end
+end

data/lib/mantra/manifest/scope/empty_scope.rb

@@ -0,0 +1,24 @@
+module Mantra
+  class Manifest
+    class Scope
+      class EmptyScope < Scope
+
+        type :empty
+
+        # returns array of children that matches this scope
+        def _filter(element)
+          [element]
+        end
+
+        def last?
+          true
+        end
+
+        def has_same_type?(element)
+          true
+        end
+
+      end
+    end
+  end
+end

data/lib/mantra/manifest/scope/hash_scope.rb

@@ -0,0 +1,20 @@
+module Mantra
+  class Manifest
+    class Scope
+      class HashScope < Scope
+
+        type :hash
+
+        # returns array of children that matches this scope
+        def _filter(element)
+          scope_regexp = to_regexp(scope)
+          element.content.each_pair.map do |pair|
+            key, value = *pair
+            key.match(scope_regexp) ? value : nil
+          end.compact
+        end
+
+      end
+    end
+  end
+end