path_mapper 0.0.2 → 0.0.3

data/lib/path_mapper/node/base/file.rb

@@ -0,0 +1,132 @@
+module PathMapper
+  module Node
+    module Base
+      module File
+        attr_accessor :changes_overlay
+
+        def method_missing(m, *args, &block)
+          kwargs = self.kwargs(args)
+          self.with_logger(logger: kwargs.delete(:logger)) do
+            self.changes_overlay = kwargs.delete(:change_overlay) if kwargs.key? :change_overlay
+            args << kwargs unless kwargs.empty?
+            self.changes_overlay.send("_#{m}", *args, &block)[:d][:result] if self.respond_to?("_#{m}")
+          end
+        end
+
+        def changes_overlay
+          @changes_overlay || self
+        end
+
+        def _create!
+          { d: { result: self }, code: :ok }
+        end
+
+        def _put!(content)
+          { d: { result: self }, code: :ok }
+        end
+
+        def _safe_put!(content)
+          { d: { result: self }, code: :ok }
+        end
+
+        def _append!(content)
+          { d: { result: self }, code: :ok }
+        end
+
+        def _remove_line!(line)
+          { d: { result: self }, code: :ok }
+        end
+
+        def _rename!(new_path)
+          self.with_dry_run do |dry_run|
+            if dry_run
+              self.storage[new_path] = self.storage_file_delete(@path)
+            else
+              ::File.rename(@path, new_path)
+            end
+          end
+          { d: { result: self._create_node(new_path) }, code: :renamed }
+        end
+
+        def _delete!(full: false)
+          { d: { result: self }, code: :ok }
+        end
+
+        def _override!(content)
+          if content.empty?
+            { d: { result: self.delete!(logger: false) }, code: :deleted }
+          else
+            self.with_dry_run do |dry_run|
+              tmp_mapper = self._create_node(@path.dirname.join(".#{@name}.tmp")).put!(content, logger: false)
+
+              if self.nil? or !self.compare_with(tmp_mapper)
+                if dry_run
+                  self.storage[@path] = tmp_mapper.raw_value
+                else
+                  tmp_mapper.rename!(@path, logger: false)
+                end
+                code = :overrided
+              else
+                tmp_mapper.delete!(logger: false)
+                code = :ok
+              end
+
+              { d: { result: self._create_node(@path) }, code: code }
+            end
+          end
+        end
+
+        def compare_with(obj)
+          return if obj.nil?
+          if obj.respond_to? :node? and obj.node?
+            self.md5 == obj.md5
+          else
+            self.md5 == Digest::MD5.new.digest(obj.to_s)
+          end
+        end
+
+        def check(line)
+          false
+        end
+
+        def md5
+          Digest::MD5.new.digest(self.value)
+        end
+
+        def diff(content)
+          content = with_line_separator(content.chomp) unless content.nil?
+          diff = Diffy::Diff.new(content, self.raw_value, diff: '-U 3').to_s
+          diff.empty? ? nil : diff
+        end
+
+        def custom_diff(a, b)
+          Diffy::Diff.new(a, b).to_s
+        end
+
+        protected
+
+        def _file_puts(content, file_mode='w')
+          return self if content.to_s.empty?
+          self.parent.create!
+
+          with_dry_run do |dry_run|
+            if dry_run
+              self.storage[@path] = case file_mode
+                when 'w' then with_line_separator(content)
+                when 'a+' then self.storage[@path].to_s + with_line_separator(content)
+              end
+            else
+              ::File.open(@path, file_mode) {|f| f.puts(content) }
+            end
+          end
+
+          self._create_node(@path)
+        end
+
+        def _general_options
+          super[:changes_overlay] = @changes_overlay if @changes_overlay != self
+        end
+      end
+    end
+  end
+end

data/lib/path_mapper/node/base/grep.rb

@@ -0,0 +1,19 @@
+module PathMapper
+  module Node
+    module Base
+      module Grep
+        def grep(reg, recursive: false, path: @path, **kwargs)
+          []
+        end
+
+        def grep_dirs(recursive: false, **kwargs)
+          []
+        end
+
+        def grep_files(recursive: false, **kwargs)
+          []
+        end
+      end
+    end
+  end
+end

data/lib/path_mapper/node/base/representation.rb

@@ -0,0 +1,73 @@
+module PathMapper
+  module Node
+    module Base
+      module Representation
+        def dir?
+          @path.directory?
+        end
+
+        def file?
+          @path.file?
+        end
+
+        def empty?
+          true
+        end
+
+        def nil?
+          false
+        end
+
+        def any?
+        end
+
+        def node?
+          true
+        end
+
+        def value
+          nil
+        end
+
+        def raw_value
+          nil
+        end
+
+        def int
+          self.value.to_i
+        end
+
+        def float
+          self.value.to_f
+        end
+
+        def bool
+        end
+
+        def lines
+          []
+        end
+
+        def json
+          JSON.load(self.value)
+        end
+
+        def to_s
+          @path.to_s
+        end
+
+        def to_str
+          self.to_s
+        end
+
+        def to_pathname
+          @path
+        end
+
+        def inspect
+          self.to_s
+        end
+      end
+    end
+  end
+end

data/lib/path_mapper/node/dir.rb

@@ -0,0 +1,31 @@
+module PathMapper
+  module Node
+    module Dir
+      include Base
+      include File
+      include Grep
+      include Representation
+      include Inheritance
+
+      def method_missing(m, *args, &block)
+        resp = self.f(m, self.kwargs(args)) if (resp = super).is_a? NilClass # Base::File
+        resp
+      end
+
+      def f(m, **kwargs)
+        def with_file_node(fname, **kwargs)
+          if (obj = self._create_node(@path.join(fname))).file?
+            yield obj
+          end
+        end
+
+        res = case m.to_s
+          when /(.*)(?=\?)/ then with_file_node($1) {|node| node.bool } || false
+          when /(.*)(?=_val)/ then with_file_node($1) {|node| node.value }
+          when /(.*)(?=_lines)/ then with_file_node($1) {|node| node.lines }
+        end
+        res.nil? ? super : res
+      end
+    end
+  end
+end

data/lib/path_mapper/node/dir/erb.rb

@@ -0,0 +1,25 @@
+module PathMapper
+  module Node
+    module Dir
+      module Erb
+        attr_reader :erb_options
+
+        def initialize(path, erb_options={})
+          super(path)
+          @erb_options = erb_options
+        end
+
+        def erb_options=(options)
+          @erb_options = options
+          self.inheritance.each {|m| m.erb_options = options }
+        end
+
+        protected
+
+        def _general_options
+          super[:erb_options] = @erb_options
+        end
+      end
+    end
+  end
+end

data/lib/path_mapper/node/dir/file.rb

@@ -0,0 +1,41 @@
+module PathMapper
+  module Node
+    module Dir
+      module File
+        def _create!
+          { d: { result: self }, code: :ok }
+        end
+
+        def _override!(content)
+          { d: { result: self }, code: :ok }
+        end
+
+        def _rename!(new_path)
+          mapper = PathMapper.new(new_path)
+          mapper.parent.create!(logger: false)
+          mapper.delete!(logger: false) unless mapper.empty?
+          super
+        end
+
+        def _delete!(full: false)
+          self.with_dry_run do |dry_run|
+            if dry_run
+              self.delete_storage_branch(@path)
+            else
+              @path.rmtree
+            end
+          end
+
+          parent = self.parent
+          parent.delete!(full: full) if parent.empty? and full
+
+          { d: { result: self._create_node(@path) }, code: :deleted }
+        end
+
+        def md5
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/path_mapper/node/dir/grep.rb

@@ -0,0 +1,38 @@
+module PathMapper
+  module Node
+    module Dir
+      module Grep
+        def grep(reg, recursive: false, path: @path, **kwargs)
+          path_ = "#{path}#{'/**' if recursive}/*"
+          files = ::Dir[path_].select {|f| f =~ reg }
+          files.map! {|f| Pathname.new(f) }
+          FilesIterator.new(files, self)
+        end
+
+        def grep_dirs(recursive: false, **kwargs)
+          self.grep(/.*/, recursive: recursive, **kwargs).select {|n| n.dir? }
+        end
+
+        def grep_files(recursive: false, **kwargs)
+          self.grep(/.*/, recursive: recursive, **kwargs).select {|n| n.file? }
+        end
+
+        class FilesIterator
+          include Enumerable
+          attr_accessor :files
+
+          def initialize(files=[], mapper)
+            self.files = files
+            @parent_mapper = mapper
+          end
+
+          def each
+            @files.each do |f|
+              yield @parent_mapper.f(f)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/path_mapper/node/dir/inheritance.rb

@@ -0,0 +1,10 @@
+module PathMapper
+  module Node
+    module Dir
+      module Inheritance
+        include Base
+        include Grep
+      end
+    end
+  end
+end

data/lib/path_mapper/node/dir/inheritance/base.rb

@@ -0,0 +1,54 @@
+module PathMapper
+  module Node
+    module Dir
+      module Inheritance
+        module Base
+          attr_writer :inheritance
+
+          def inheritance
+            @inheritance ||= []
+          end
+
+          def <<(mapper)
+            self.inheritance << mapper
+          end
+
+          def f(m, overlay: true, **kwargs)
+            def with_inheritance(obj, **kwargs)
+              if obj.respond_to? :dir? and obj.dir?
+                obj.inheritance = self.inheritance.map do |inheritor|
+                  next if inheritor.path == obj.path.dirname
+                  unless (resp = inheritor.f(obj.name, kwargs)).empty?
+                    resp
+                  end
+                end.compact
+              end
+              obj.changes_overlay = self._create_node(self.changes_overlay.path.join(obj.name))
+              obj
+            end
+
+            resp = []
+            base_resp = nil
+            ["#{m.to_s}.erb", m.to_s].each {|fname| base_resp = with_inheritance(self._create_node(@path.join(fname)), kwargs) if base_resp.nil? }
+            resp << base_resp
+            self.inheritance.each do |inherit|
+              unless (resp_ = with_inheritance(inherit.f(m, kwargs), kwargs)).nil?
+                if overlay
+                  return resp_
+                else
+                  resp << resp_
+                end
+              end
+            end if !overlay || (overlay and base_resp.empty?)
+
+            if base_resp.empty? and kwargs.key? :default
+              kwargs[:default]
+            else
+              overlay ? resp.first : resp.select {|node| !node.is_a? Null }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/path_mapper/node/dir/inheritance/grep.rb

@@ -0,0 +1,22 @@
+module PathMapper
+  module Node
+    module Dir
+      module Inheritance
+        module Grep
+          def grep(reg, recursive: false, path: @path, overlay: true)
+            files_iterator = super
+            self.inheritance.each do |inheritor|
+              inheritor_files_iterator = super(reg, path: inheritor.path)
+              files_iterator.files += if overlay
+                inheritor_files_iterator.files.select {|f| !files_iterator.files.any? {|f_| f_.basename.to_s[/(.*(?=\.erb))|(.*)/] == f.basename.to_s[/(.*(?=\.erb))|(.*)/] } }
+              else
+                inheritor_files_iterator.files
+              end
+            end
+            files_iterator
+          end
+        end
+      end
+    end
+  end
+end