yaml-vfs 0.0.2 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bb77a02e5dff7b58ddbb164d61e7b1ffd1ffdd0ec0ddf816aaf6189462de0105
-  data.tar.gz: aea8cbd0ffb9eed48a942edc211fcbbc6378b1047aa72ff63e389dd31d513702
+  metadata.gz: 3e4890cc09e0ec81ac2207d17794117c63e5a75b11119df87560083c0affb2b6
+  data.tar.gz: c863931919a9d44647d17ce9612668f89aba9392c00cf515c4b5f5f97e7074c7
 SHA512:
-  metadata.gz: b6962cb728e59c07c08c00276a80a489b1707b3239c2d037d743159e04f907bbea961504944fb9b60b268b70e589e0bbcdf890d701eb5fa1aad5747d1339a03e
-  data.tar.gz: ad4386f7f3fb7d9c3643bb525de459b93a0c99b848226c34de64c15c1266ff40fb479d1f8e97408d8ae4813a804ea3044d5bb2ad5e2f1b9573106d988a65f706
+  metadata.gz: 72ee57fdaff9d9a559a7af00fae9be99355f3cffbde3ea6d88580609f8298153fcc383352b3a15bc268694be005697abfad10b53ecd83a02bc881ff9096bab00
+  data.tar.gz: c5acbf1325db6cf85bdaea38c7950e00ff057d6e5fef90d836a4bd770842b63e61c895251a42cd29e0e1e94c7dc9e5087886237852b5c5fd15323a822e233572

data/lib/yaml-vfs/command/yaml_vfs_writer.rb

@@ -3,7 +3,7 @@
 module VFS
   class Command
     # vfs yaml file gen cmd
-    class YAMLWriter < Command
+    class Framework < Command
       # summary
       self.summary = 'Virtual the framework and modules dir, and map to real path'
 
@@ -51,7 +51,61 @@ module VFS
       def run
         require 'yaml_vfs'
 
-        VFS::FileCollector.new_from_real_headers_dir(@framework_path, @real_modules_dir, @real_header_dir).write_mapping(@output_path)
+        entrys = VFS::FileCollectorEntry.entrys_from_framework_dir(@framework_path, @real_header_dir, @real_modules_dir)
+        VFS::FileCollector.new(entrys).write_mapping(@output_path)
+      end
+    end
+    class Target < Command
+      # summary
+      self.summary = 'Virtual the target public and private headers, and map to real path'
+
+      self.description = <<-DESC
+        Gen VFS Yaml file. To map target virtual path to real path.
+      DESC
+
+      self.arguments = [
+        # target_p, public_header, private_header
+        CLAide::Argument.new('--target-path', true),
+        CLAide::Argument.new('--public-headers-dir', true),
+        CLAide::Argument.new('--private-headers-dir', true),
+        CLAide::Argument.new('--output-path', false)
+      ]
+
+      def initialize(argv)
+        super
+
+        target_path = argv.option('target-path')
+        @target_path = Pathname(target_path) unless target_path.nil?
+        public_headers_dir = argv.option('public-headers-dir')
+        @public_headers_dir = Pathname(public_headers_dir) unless public_headers_dir.nil?
+        private_headers_dir = argv.option('private-headers-dir')
+        @private_headers_dir = Pathname(private_headers_dir) unless private_headers_dir.nil?
+        output_path = argv.option('output-path')
+        @output_path = output_path.nil? ? Pathname('.') : Pathname(output_path)
+      end
+
+      def validate!
+        super
+        help! 'must set --target-path' if @target_path.nil?
+        help! 'must set --public-headers-dir' if @public_headers_dir.nil?
+        help! 'must set --private-headers-dir' if @private_headers_dir.nil?
+      end
+
+      # help
+      def self.options
+        [
+          ['--target-pathh=<path>', 'target path'],
+          ['--public-headers-dir=<path>', 'real public headers path'],
+          ['--private-headers-dir=<path>', 'real private headers path'],
+          ['--output-path=<path>', 'vfs yaml file output path']
+        ].concat(super)
+      end
+
+      def run
+        require 'yaml_vfs'
+
+        entrys = VFS::FileCollectorEntry.entrys_from_target_dir(@target_path, @public_headers_dir, @private_headers_dir)
+        VFS::FileCollector.new(entrys).write_mapping(@output_path)
       end
     end
   end

data/lib/yaml-vfs/file_collector.rb

@@ -1,58 +1,109 @@
 # frozen_string_literal: true
 
 require 'set'
-require 'yaml-vfs/yaml_vfs'
 
 module VFS
-  # vfs gen
-  class FileCollector
-    HEADER_FILES_EXTENSIONS = %w[.h .hh .hpp .ipp .tpp .hxx .def .inl .inc].freeze
+  HEADER_FILES_EXTENSIONS = %w[.h .hh .hpp .ipp .tpp .hxx .def .inl .inc].freeze
+  VFS_FILES_EXTENSIONS = %w[.yaml .yml .json].freeze
+  # vfs file collector entry
+  class FileCollectorEntry
+    attr_reader :real_path, :virtual_path
+
+    def initialize(real_path, virtual_path)
+      raise ArgumentError, 'real_path or virtual_path must set' if real_path.nil? || virtual_path.empty?
+
+      @real_path = Pathname(real_path)
+      @virtual_path = Pathname(virtual_path)
+    end
+
+    def self.entrys_from_framework(framework_path, public_headers, private_headers, real_modules)
+      entrys = {}
+      entrys['Headers'] = public_headers unless public_headers.empty?
+      entrys['PrivateHeaders'] = private_headers unless private_headers.empty?
+      entrys['Modules'] = real_modules unless real_modules.empty?
+
+      entrys.flat_map do |key, values|
+        values.map do |path|
+          v_p = File.join(framework_path, key, File.basename(path))
+          new(path, v_p)
+        end
+      end
+    end
 
-    attr_reader :framework_path, :real_modules, :real_headers
+    def self.entrys_from_framework_dir(framework_path, real_header_dir, real_modules_dir)
+      raise ArgumentError, 'real_header must set and exist' unless File.exist?(real_header_dir || '')
+      raise ArgumentError, 'real_modules must set and exist' unless File.exist?(real_header_dir || '')
+
+      real_header_dir = File.join(real_header_dir, '**', '*')
+      real_headers = Pathname.glob(real_header_dir).select { |file| HEADER_FILES_EXTENSIONS.include?(file.extname) }
+      real_modules = Pathname(real_modules_dir).glob('module*.modulemap') || []
+      entrys_from_framework(framework_path, real_headers, real_modules)
+    end
 
-    def self.new_from_real_headers_dir(framework_path, real_modules_dir, real_header_dir)
-      raise ArgumentError, 'real_header_dir must set and exist' if real_header_dir.nil? || !real_header_dir.exist?
+    def self.entrys_from_target(target_path, public_headers, private_headers)
+      entrys = {}
+      entrys['Headers'] = public_headers unless public_headers.empty?
+      entrys['PrivateHeaders'] = private_headers unless private_headers.empty?
 
-      files = Pathname.glob(Pathname(real_header_dir).join('**').join('*')).select do |file|
-        HEADER_FILES_EXTENSIONS.include?(file.extname)
+      entrys.flat_map do |key, values|
+        values.map do |path|
+          v_p = File.join(target_path, key, File.basename(path))
+          new(path, v_p)
+        end
       end
-      real_modules = Pathname(real_modules_dir).glob('module*.modulemap')
-      new(framework_path, real_modules, files)
     end
 
-    def initialize(framework_path, real_modules, real_headers)
-      @seen = Set.new
+    def self.entrys_from_target_dir(target_path, public_dir, private_dir)
+      headers = lambda do |dir|
+        unless dir.nil? && File.exist?(dir)
+          Pathname.glob(File.join(dir, '**', '*')).select do |file|
+            HEADER_FILES_EXTENSIONS.include?(file.extname)
+          end
+        end
+      end
+      private_headers = headers.call(private_dir) || []
+      public_headers = headers.call(public_dir) || []
+      entrys_from_target(target_path, public_headers, private_headers)
+    end
+  end
+
+  # vfs gen
+  class FileCollector
+    EMPTY_VFS_FILE = '{"case-sensitive":"false","roots":[],"version":0}'
+    private_constant :EMPTY_VFS_FILE
+    def initialize(entrys)
+      @entrys = entrys || []
       @vfs_writer = YAMLVFSWriter.new
-      @real_headers = real_headers
-      @framework_path = Pathname(framework_path)
-      @real_modules = real_modules
     end
 
     def write_mapping(name)
-      raise ArgumentError, 'framework_path must set' if @framework_path.nil?
-      raise ArgumentError, 'real_headers or real_header_dir one of them must set' if @real_headers.empty?
-
-      add_write_file
-      @vfs_writer.case_sensitive = false
+      stream = add_write_file
       path = Pathname(name).expand_path
-      path = path.join('all-product-headers.yaml') if path.directory?
-      stream = @vfs_writer.write
-      path.dirname.mkpath
-      File.open(path, 'w') { |f| f.write(stream) }
+      unless VFS_FILES_EXTENSIONS.include?(File.extname(path))
+        path.mkpath unless path.exist?
+        path = path.join('all-product-headers.yaml')
+      end
+      update_changed_file(path, stream)
     end
 
     private
 
+    def update_changed_file(path, contents)
+      if path.exist?
+        content_stream = StringIO.new(contents)
+        identical = File.open(path, 'rb') { |f| FileUtils.compare_stream(f, content_stream) }
+        return if identical
+      end
+      path.dirname.mkpath
+      File.open(path, 'w') { |f| f.write(contents) }
+    end
+
     def add_write_file
-      wirte_f = lambda { |dir, files|
-        paths = @framework_path.join(dir)
-        files.each do |file|
-          path = paths.join(file.basename)
-          @vfs_writer.add_file_mapping(path, file)
-        end
-      }
-      wirte_f.call('Headers', real_headers) unless real_headers.empty?
-      wirte_f.call('Modules', real_modules) unless real_modules.empty?
+      return EMPTY_VFS_FILE if @entrys.empty?
+
+      @entrys.each { |entry| @vfs_writer.add_file_mapping(entry.virtual_path, entry.real_path) }
+      @vfs_writer.case_sensitive = false
+      @vfs_writer.write
     end
   end
 end

data/lib/yaml-vfs/utils.rb

@@ -12,11 +12,11 @@ end
 String.class_eval do
   def indent(count, char = ' ')
     gsub(/([^\n]*)(\n|$)/) do
-      last_iteration = ($1 == '' && $2 == '')
+      last_iteration = (Regexp.last_match(1) == '' && Regexp.last_match(2) == '')
       line = ''
       line << (char * count) unless last_iteration
-      line << $1
-      line << $2
+      line << Regexp.last_match(1)
+      line << Regexp.last_match(2)
       line
     end
   end

data/lib/yaml-vfs/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module VFS
-  VERSION = '0.0.2'
+  VERSION = '0.0.5'
 end

data/lib/yaml-vfs/yaml_vfs.rb

@@ -1,4 +1,4 @@
-# frozen_string_literal: true
+# frozen_string_literal: false
 
 require 'pathname'
 require 'json'
@@ -82,14 +82,6 @@ module VFS
 
     private
 
-    def dir_indent
-      @dir_stack.length * 4
-    end
-
-    def file_indent
-      (@dir_stack.length + 1) * 4
-    end
-
     def contained_in?(parent, path)
       path.ascend { |p| break true if parent == p } || false
     end
@@ -104,27 +96,24 @@ module VFS
     def start_directory(path)
       name = @dir_stack.empty? ? path : contained_part(@dir_stack.last, path)
       @dir_stack << path
-      indent = dir_indent
-      @stream += "{\n".indent(indent)
-      @stream += "'type': 'directory',\n".indent(indent + 2)
-      @stream += "'name': \"#{name}\",\n".indent(indent + 2)
-      @stream += "'contents': [\n".indent(indent + 2)
+      @stream << '{'
+      @stream << "'type':'directory',"
+      @stream << "'name':\"#{name}\","
+      @stream << "'contents':["
     end
 
     def end_directory
-      indent = dir_indent
-      @stream += "]\n".indent(indent + 2)
-      @stream += '}'.indent(indent)
+      @stream << ']'
+      @stream << '}'
       @dir_stack.pop
     end
 
     def write_entry(v_path, r_path)
-      indent = file_indent
-      @stream += "{\n".indent(indent)
-      @stream += "'type': 'file',\n".indent(indent + 2)
-      @stream += "'name': \"#{v_path}\",\n".indent(indent + 2)
-      @stream += "'external-contents': \"#{r_path}\"\n".indent(indent + 2)
-      @stream += '}'.indent(file_indent)
+      @stream << '{'
+      @stream << "'type':'file',"
+      @stream << "'name':\"#{v_path}\","
+      @stream << "'external-contents':\"#{r_path}\""
+      @stream << '}'
     end
 
     def overlay_dir_sub_rpath(use, overlay_dir, rpath)
@@ -137,24 +126,18 @@ module VFS
     end
 
     def write_yaml_header(use_external_names, case_sensitive, overlay_relative, _overlay_dir)
-      @stream = "{\n  'version': 0,\n"
-      @stream += "  'case-sensitive': '#{case_sensitive}',\n" unless case_sensitive.nil?
-      @stream += "  'use-external-names': '#{use_external_names}',\n" unless use_external_names.nil?
+      @stream = "{'version':0,"
+      @stream << "'case-sensitive':'#{case_sensitive}'," unless case_sensitive.nil?
+      @stream << "'use-external-names':'#{use_external_names}'," unless use_external_names.nil?
       use_overlay_relative = !overlay_relative.nil?
-      @stream += "  'overlay_relative': '#{overlay_relative}',\n" if use_overlay_relative
-      @stream += "  'roots': [\n"
+      @stream << "'overlay_relative':'#{overlay_relative}'," if use_overlay_relative
+      @stream << "'roots':["
       use_overlay_relative
     end
 
     def write_yaml_footer(entries)
-      unless entries.empty?
-        until @dir_stack.empty?
-          @stream += "\n"
-          end_directory
-        end
-        @stream += "\n"
-      end
-      @stream += "  ]\n}\n"
+      end_directory until @dir_stack.empty? unless entries.empty?
+      @stream << ']}'
       @stream
     end
 
@@ -170,7 +153,6 @@ module VFS
     def until_end_directory(dir)
       dir_popped_from_stack = false
       until @dir_stack.empty? || contained_in?(@dir_stack.last, dir)
-        @stream += "\n"
         end_directory
         dir_popped_from_stack = true
       end
@@ -188,13 +170,149 @@ module VFS
 
     def start_directory_or_return(dir, current_dir_empty, use_overlay_relative, overlay_dir, entry)
       if dir == @dir_stack.last
-        @stream += ",\n" unless current_dir_empty
+        @stream << ',' unless current_dir_empty
       else
-        @stream += ",\n" if until_end_directory(dir) || !current_dir_empty
+        @stream << ',' if until_end_directory(dir) || !current_dir_empty
         start_directory(dir)
         current_dir_empty = true
       end
       use_overlay_relative_and_write_entry(use_overlay_relative, overlay_dir, current_dir_empty, entry)
     end
   end
+  # class JSONWriter
+  #   attr_reader :dir_stack
+
+  #   def write(entries, use_external_names, case_sensitive, overlay_relative, overlay_dir)
+  #     use_overlay_relative = write_yaml_header(use_external_names, case_sensitive, overlay_relative, overlay_dir)
+  #     unless entries.empty?
+  #       current_dir_empty = write_root_entry(entries, use_overlay_relative, overlay_dir)
+  #       entries.drop(1).reduce(current_dir_empty) do |empty, entry|
+  #         dir = entry.directory? ? entry.v_path : entry.v_path.dirname
+  #         start_directory_or_return(dir, empty, use_overlay_relative, overlay_dir, entry)
+  #       end
+  #     end
+  #     write_yaml_footer(entries)
+  #   end
+
+  #   def initialize
+  #     @dir_stack = []
+  #   end
+
+  #   private
+
+  #   def dir_indent
+  #     @dir_stack.length * 4
+  #   end
+
+  #   def file_indent
+  #     (@dir_stack.length + 1) * 4
+  #   end
+
+  #   def contained_in?(parent, path)
+  #     path.ascend { |p| break true if parent == p } || false
+  #   end
+
+  #   def contained_part(parent, path)
+  #     raise ArgumentError if parent.nil?
+  #     raise ArgumentError unless contained_in?(parent, path)
+
+  #     path.relative_path_from(parent)
+  #   end
+
+  #   def start_directory(path)
+  #     name = @dir_stack.empty? ? path : contained_part(@dir_stack.last, path)
+  #     @dir_stack << path
+  #     indent = dir_indent
+  #     @stream += "{\n"
+  #     @stream += "'type': 'directory',\n".indent(indent + 2)
+  #     @stream += "'name': \"#{name}\",\n".indent(indent + 2)
+  #     @stream += "'contents': [\n".indent(indent + 2)
+  #   end
+
+  #   def end_directory
+  #     indent = dir_indent
+  #     @stream += "]\n".indent(indent + 2)
+  #     @stream += '}'
+  #     @dir_stack.pop
+  #   end
+
+  #   def write_entry(v_path, r_path)
+  #     indent = file_indent
+  #     @stream += "{\n"
+  #     @stream += "'type': 'file',\n".indent(indent + 2)
+  #     @stream += "'name': \"#{v_path}\",\n".indent(indent + 2)
+  #     @stream += "'external-contents': \"#{r_path}\"\n".indent(indent + 2)
+  #     @stream += '}'.indent(file_indent)
+  #   end
+
+  #   def overlay_dir_sub_rpath(use, overlay_dir, rpath)
+  #     if use
+  #       raise ArgumentError, 'Overlay dir must be contained in RPath' unless rpath.fnmatch?("#{overlay_dir}*")
+
+  #       rpath = rpath.relative_path_from(overlay_dir).expand_path
+  #     end
+  #     rpath
+  #   end
+
+  #   def write_yaml_header(use_external_names, case_sensitive, overlay_relative, _overlay_dir)
+  #     @stream = "{\n  'version': 0,\n"
+  #     @stream += "  'case-sensitive': '#{case_sensitive}',\n" unless case_sensitive.nil?
+  #     @stream += "  'use-external-names': '#{use_external_names}',\n" unless use_external_names.nil?
+  #     use_overlay_relative = !overlay_relative.nil?
+  #     @stream += "  'overlay_relative': '#{overlay_relative}',\n" if use_overlay_relative
+  #     @stream += "  'roots': [\n"
+  #     use_overlay_relative
+  #   end
+
+  #   def write_yaml_footer(entries)
+  #     unless entries.empty?
+  #       until @dir_stack.empty?
+  #         @stream += "\n"
+  #         end_directory
+  #       end
+  #       @stream += "\n"
+  #     end
+  #     @stream += "  ]\n}\n"
+  #     @stream
+  #   end
+
+  #   def write_root_entry(entries, use_overlay_relative, overlay_dir)
+  #     return true if entries.empty?
+
+  #     f_entry = entries.first
+  #     start_directory(f_entry.directory? ? f_entry.v_path : f_entry.v_path.dirname)
+  #     current_dir_empty = f_entry.directory?
+  #     use_overlay_relative_and_write_entry(use_overlay_relative, overlay_dir, current_dir_empty, f_entry)
+  #   end
+
+  #   def until_end_directory(dir)
+  #     dir_popped_from_stack = false
+  #     until @dir_stack.empty? || contained_in?(@dir_stack.last, dir)
+  #       @stream += "\n"
+  #       end_directory
+  #       dir_popped_from_stack = true
+  #     end
+  #     dir_popped_from_stack
+  #   end
+
+  #   def use_overlay_relative_and_write_entry(use_overlay_relative, overlay_dir, current_dir_empty, entry)
+  #     rpath = overlay_dir_sub_rpath(use_overlay_relative, overlay_dir, entry.r_path)
+  #     unless entry.directory?
+  #       write_entry(entry.v_path.basename, rpath)
+  #       current_dir_empty = false
+  #     end
+  #     current_dir_empty
+  #   end
+
+  #   def start_directory_or_return(dir, current_dir_empty, use_overlay_relative, overlay_dir, entry)
+  #     if dir == @dir_stack.last
+  #       @stream += ",\n" unless current_dir_empty
+  #     else
+  #       @stream += ",\n" if until_end_directory(dir) || !current_dir_empty
+  #       start_directory(dir)
+  #       current_dir_empty = true
+  #     end
+  #     use_overlay_relative_and_write_entry(use_overlay_relative, overlay_dir, current_dir_empty, entry)
+  #   end
+  # end
 end

data/lib/yaml_vfs.rb

@@ -16,10 +16,10 @@ module VFS
     end
   end
 
+  require_relative 'yaml-vfs/yaml_vfs'
   require_relative 'yaml-vfs/version'
   require_relative 'yaml-vfs/utils'
+  require_relative 'yaml-vfs/file_collector'
 
-
-  autoload :FileCollector, 'yaml-vfs/file_collector'
   autoload :Command, 'yaml-vfs/command'
 end

metadata

@@ -1,43 +1,35 @@
 --- !ruby/object:Gem::Specification
 name: yaml-vfs
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.5
 platform: ruby
 authors:
 - Cat1237
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-09-07 00:00:00.000000000 Z
+date: 2022-05-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '2.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '2.1'
-- !ruby/object:Gem::Dependency
-  name: coveralls
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement