RubyGems - mustermann-fileutils - Versions diffs - 0.4.0 - Mend

mustermann-fileutils 0.4.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (8) hide show

checksums.yaml +7 -0
data/README.md +57 -0
data/lib/mustermann/file_utils.rb +217 -0
data/lib/mustermann/file_utils/glob_pattern.rb +39 -0
data/lib/mustermann/fileutils.rb +1 -0
data/mustermann-fileutils.gemspec +18 -0
data/spec/file_utils_spec.rb +119 -0
metadata +65 -0

checksums.yaml ADDED

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f3a4166e01feb70f7f2ff3638a75485a5b7dac48
+  data.tar.gz: 3e30d5bce9ecaa69a9c06710553ac9083a1600b9
+SHA512:
+  metadata.gz: 2dce4ceac77fff3bb5d4f6432c13051d7e921535dee68fcb927b9b547b782e8e249b9cc2478a90fbf3bfd5aa5ce12cd4f9113ee3f0c4169889ec590f5ff7d4cc
+  data.tar.gz: fffe449bde8a545785cd3102520fb892241e5e130728e322107d9482e504c7cd94e8dda958cd200307366a26678c4aa44d24643d52cfc103c5c4318e9af28989

data/README.md ADDED

@@ -0,0 +1,57 @@
+# FileUtils for Mustermann
+This gem implements efficient file system operations for Mustermann patterns.
+## Globbing
+All operations work on a list of files described by one or more pattern.
+``` ruby
+require 'mustermann/file_utils'
+Mustermann::FileUtils[':base.:ext'] # => ['example.txt']
+Mustermann::FileUtils.glob(':base.:ext') do |file, params|
+  file   # => "example.txt"
+  params # => {"base"=>"example", "ext"=>"txt"}
+end
+```
+To avoid having to loop over all files and see if they match, it will generate a glob pattern resembling the Mustermann pattern as closely as possible.
+``` ruby
+require 'mustermann/file_utils'
+Mustermann::FileUtils.glob_pattern('/:name')                  # => '/*'
+Mustermann::FileUtils.glob_pattern('src/:path/:file.(js|rb)') # => 'src/**/*/*.{js,rb}'
+Mustermann::FileUtils.glob_pattern('{a,b}/*', type: :shell)   # => '{a,b}/*'
+pattern = Mustermann.new('/foo/:page', '/bar/:page') # => #<Mustermann::Composite:...>
+Mustermann::FileUtils.glob_pattern(pattern)          # => "{/foo/*,/bar/*}"
+```
+## Mapping
+It is also possible to search for files and have their paths mapped onto another path in one method call:
+``` ruby
+require 'mustermann/file_utils'
+Mustermann::FileUtils.glob_map(':base.:ext' => ':base.bak.:ext') # => {'example.txt' => 'example.bak.txt'}
+Mustermann::FileUtils.glob_map(':base.:ext' => :base) { |file, mapped| mapped } # => ['example']
+```
+This mechanism allows things like copying, renaming and linking files:
+``` ruby
+require 'mustermann/file_utils'
+# copies example.txt to example.bak.txt
+Mustermann::FileUtils.cp(':base.:ext' => ':base.bak.:ext')
+# copies Foo.app/example.txt to Foo.back.app/example.txt
+Mustermann::FileUtils.cp_r(':base.:ext' => ':base.bak.:ext')
+# creates a symbolic link from bin/example to lib/example.rb
+Mustermann::FileUtils.ln_s('lib/:name.rb' => 'bin/:name')
+```

data/lib/mustermann/file_utils.rb ADDED

@@ -0,0 +1,217 @@
+require 'mustermann'
+require 'mustermann/file_utils/glob_pattern'
+require 'mustermann/mapper'
+require 'fileutils'
+module Mustermann
+  # Implements handy file operations using patterns.
+  module FileUtils
+    extend self
+    # Turn a Mustermann pattern into glob pattern.
+    #
+    # @example
+    #   require 'mustermann/file_utils'
+    #
+    #   Mustermann::FileUtils.glob_pattern('/:name')                  # => '/*'
+    #   Mustermann::FileUtils.glob_pattern('src/:path/:file.(js|rb)') # => 'src/**/*/*.{js,rb}'
+    #   Mustermann::FileUtils.glob_pattern('{a,b}/*', type: :shell)   # => '{a,b}/*'
+    #
+    #   pattern = Mustermann.new('/foo/:page', '/bar/:page') # => #<Mustermann::Composite:...>
+    #   Mustermann::FileUtils.glob_pattern(pattern)          # => "{/foo/*,/bar/*}"
+    #
+    # @param [Object] pattern the object to turn into a glob pattern.
+    # @return [String] the glob pattern
+    def glob_pattern(*pattern, **options)
+      pattern_with_glob_pattern(*pattern, **options).last
+    end
+    # Uses the given pattern(s) to search for files and directories.
+    #
+    # @example
+    #   require 'mustermann/file_utils'
+    #   Mustermann::FileUtils.glob(':base.:ext') # => ['example.txt']
+    #
+    #   Mustermann::FileUtils.glob(':base.:ext') do |file, params|
+    #     file   # => "example.txt"
+    #     params # => {"base"=>"example", "ext"=>"txt"}
+    #   end
+    def glob(*pattern, **options, &block)
+      raise ArgumentError, "no pattern given" if pattern.empty?
+      pattern, glob_pattern = pattern_with_glob_pattern(*pattern, **options)
+      results               = [] unless block
+      Dir.glob(glob_pattern) do |result|
+        next unless params = pattern.params(result)
+        block ? block[result, params] : results << result
+      end
+      results
+    end
+    # Allows to search for files an map these onto other strings.
+    #
+    # @example
+    #   require 'mustermann/file_utils'
+    #
+    #   Mustermann::FileUtils.glob_map(':base.:ext' => ':base.bak.:ext') # => {'example.txt' => 'example.bak.txt'}
+    #   Mustermann::FileUtils.glob_map(':base.:ext' => :base) { |file, mapped| mapped } # => ['example']
+    #
+    # @see Mustermann::Mapper
+    def glob_map(map = {}, **options, &block)
+      map    = Mapper === map ? map : Mapper.new(map, **options)
+      mapped = glob(*map.to_h.keys).map { |f| [f, unescape(map[f])] }
+      block ? mapped.map(&block) : Hash[mapped]
+    end
+    # Copies files based on a pattern mapping.
+    #
+    # @example
+    #   require 'mustermann/file_utils'
+    #
+    #   # copies example.txt to example.bak.txt
+    #   Mustermann::FileUtils.cp(':base.:ext' => ':base.bak.:ext')
+    #
+    # @see #glob_map
+    def cp(map = {}, recursive: false, **options)
+      utils_opts, opts = split_options(:preserve, :dereference_root, :remove_destination, **options)
+      cp_method        = recursive ? :cp_r : :cp
+      glob_map(map, **opts) { |o,n| f.send(cp_method, o, n, **utils_opts) }
+    end
+    # Copies files based on a pattern mapping, recursively.
+    #
+    # @example
+    #   require 'mustermann/file_utils'
+    #
+    #   # copies Foo.app/example.txt to Foo.back.app/example.txt
+    #   Mustermann::FileUtils.cp_r(':base.:ext' => ':base.bak.:ext')
+    #
+    # @see #glob_map
+    def cp_r(map = {}, **options)
+      cp(map, recursive: true, **options)
+    end
+    # Moves files based on a pattern mapping.
+    #
+    # @example
+    #   require 'mustermann/file_utils'
+    #
+    #   # moves example.txt to example.bak.txt
+    #   Mustermann::FileUtils.mv(':base.:ext' => ':base.bak.:ext')
+    #
+    # @see #glob_map
+    def mv(map = {}, **options)
+      utils_opts, opts = split_options(**options)
+      glob_map(map, **opts) { |o,n| f.mv(o, n, **utils_opts) }
+    end
+    # Creates links based on a pattern mapping.
+    #
+    # @example
+    #   require 'mustermann/file_utils'
+    #
+    #   # creates a link from bin/example to lib/example.rb
+    #   Mustermann::FileUtils.ln('lib/:name.rb' => 'bin/:name')
+    #
+    # @see #glob_map
+    def ln(map = {}, symbolic: false, **options)
+      utils_opts, opts = split_options(**options)
+      link_method      = symbolic ? :ln_s : :ln
+      glob_map(map, **opts) { |o,n| f.send(link_method, o, n, **utils_opts) }
+    end
+    # Creates symbolic links based on a pattern mapping.
+    #
+    # @example
+    #   require 'mustermann/file_utils'
+    #
+    #   # creates a symbolic link from bin/example to lib/example.rb
+    #   Mustermann::FileUtils.ln_s('lib/:name.rb' => 'bin/:name')
+    #
+    # @see #glob_map
+    def ln_s(map = {}, **options)
+      ln(map, symbolic: true, **options)
+    end
+    # Creates symbolic links based on a pattern mapping.
+    # Overrides potentailly existing files.
+    #
+    # @example
+    #   require 'mustermann/file_utils'
+    #
+    #   # creates a symbolic link from bin/example to lib/example.rb
+    #   Mustermann::FileUtils.ln_sf('lib/:name.rb' => 'bin/:name')
+    #
+    # @see #glob_map
+    def ln_sf(map = {}, **options)
+      ln(map, symbolic: true, force: true, **options)
+    end
+    # Splits options into those meant for Mustermann and those
+    # meant for ::FileUtils.
+    #
+    # @!visibility private
+    def split_options(*utils_option_names, **options)
+      utils_options, pattern_options = {}, {}
+      utils_option_names += %i[force noop verbose]
+      options.each do |key, value|
+        list = utils_option_names.include?(key) ? utils_options : pattern_options
+        list[key] = value
+      end
+      [utils_options, pattern_options]
+    end
+    # Create a Mustermann pattern from whatever the input is and turn it into
+    # a glob pattern.
+    #
+    # @!visibility private
+    def pattern_with_glob_pattern(*pattern, **options)
+      options[:uri_decode]    ||= false
+      pattern                   = Mustermann.new(*pattern.flatten, **options)
+      @glob_patterns          ||= {}
+      @glob_patterns[pattern] ||= GlobPattern.generate(pattern)
+      [pattern, @glob_patterns[pattern]]
+    end
+    # The FileUtils method to use.
+    # @!visibility private
+    def f
+      ::FileUtils
+    end
+    # Unescape an URI escaped string.
+    # @!visibility private
+    def unescape(string)
+      @uri ||= URI::Parser.new
+      @uri.unescape(string)
+    end
+    # Create a new version of Mustermann::FileUtils using a different ::FileUtils module.
+    # @see DryRun
+    # @!visibility private
+    def with_file_utils(&block)
+      Module.new do
+        include Mustermann::FileUtils
+        define_method(:f, &block)
+        private(:f)
+        extend self
+      end
+    end
+    private :pattern_with_glob_pattern, :split_options, :f, :unescape
+    alias_method :copy,     :cp
+    alias_method :move,     :mv
+    alias_method :link,     :ln
+    alias_method :symlink,  :ln_s
+    alias_method :[],       :glob
+    DryRun  ||= with_file_utils { ::FileUtils::DryRun  }
+    NoWrite ||= with_file_utils { ::FileUtils::NoWrite }
+    Verbose ||= with_file_utils { ::FileUtils::Verbose }
+  end
+end

data/lib/mustermann/file_utils/glob_pattern.rb ADDED

@@ -0,0 +1,39 @@
+require 'mustermann/ast/translator'
+module Mustermann
+  module FileUtils
+    # AST Translator to turn Mustermann patterns into glob patterns.
+    # @!visibility private
+    class GlobPattern < Mustermann::AST::Translator
+      # Character that need to be escaped in glob patterns.
+      # @!visibility private
+      ESCAPE = %w([ ] { } * ** \\)
+      # Turn a Mustermann pattern into glob pattern.
+      # @param [#to_glob, #to_ast, Object] pattern the object to turn into a glob pattern.
+      # @return [String] the glob pattern
+      # @!visibility private
+      def self.generate(pattern)
+        return pattern.to_glob               if pattern.respond_to? :to_glob
+        return new.translate(pattern.to_ast) if pattern.respond_to? :to_ast
+        return "**/*" unless pattern.is_a? Mustermann::Composite
+        "{#{pattern.patterns.map { |p| generate(p) }.join(',')}}"
+      end
+      translate(:root, :group, :expression) { t(payload) || ""                           }
+      translate(:separator, :char)          { t.escape(payload)                          }
+      translate(:capture)                   { constraint ? "**/*" : "*"                  }
+      translate(:optional)                  { "{#{t(payload)},}"                         }
+      translate(:named_splat, :splat)       { "**/*"                                     }
+      translate(:with_look_ahead)           { t(head) + t(payload)                       }
+      translate(:union)                     { "{#{payload.map { |e| t(e) }.join(',')}}"  }
+      translate(Array)                      { map { |e| t(e) }.join                      }
+      # Escape with a slash rather than URI escaping.
+      # @!visibility private
+      def escape(char)
+        ESCAPE.include?(char) ? "\\#{char}" : char
+      end
+    end
+  end
+end

data/lib/mustermann/fileutils.rb ADDED

	@@ -0,0 +1 @@
1	+ require 'mustermann/file_utils'

data/mustermann-fileutils.gemspec ADDED

@@ -0,0 +1,18 @@
+$:.unshift File.expand_path("../../mustermann/lib", __FILE__)
+require "mustermann/version"
+Gem::Specification.new do |s|
+  s.name                  = "mustermann-fileutils"
+  s.version               = Mustermann::VERSION
+  s.author                = "Konstantin Haase"
+  s.email                 = "konstantin.mailinglists@googlemail.com"
+  s.homepage              = "https://github.com/rkh/mustermann"
+  s.summary               = %q{File Utils for Mustermann}
+  s.description           = %q{Operate efficiently on your file system using Mustermann}
+  s.license               = 'MIT'
+  s.required_ruby_version = '>= 2.1.0'
+  s.files                 = `git ls-files`.split("\n")
+  s.test_files            = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables           = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.add_dependency 'mustermann', Mustermann::VERSION
+end

data/spec/file_utils_spec.rb ADDED

@@ -0,0 +1,119 @@
+require 'support'
+require 'mustermann/file_utils'
+describe Mustermann::FileUtils do
+  subject(:utils) { Mustermann::FileUtils }
+  include FileUtils
+  before do
+    @pwd     = Dir.pwd
+    @tmp_dir = File.join(__dir__, 'tmp')
+    mkdir_p(@tmp_dir)
+    chdir(@tmp_dir)
+    touch("foo.txt")
+    touch("foo.rb")
+    touch("bar.txt")
+    touch("bar.rb")
+  end
+  after do
+    chdir(@pwd)           if @pwd
+    rm_rf(@tmp_dir) if @tmp_dir
+  end
+  describe :glob_pattern do
+    example { utils.glob_pattern('/:foo')                 .should be == '/*'                  }
+    example { utils.glob_pattern('/*foo')                 .should be == '/**/*'               }
+    example { utils.glob_pattern('/(ab|c)?/:foo/d/*bar')  .should be == '/{{ab,c},}/*/d/**/*' }
+    example { utils.glob_pattern('/a', '/b')              .should be == '{/a,/b}'             }
+    example { utils.glob_pattern('**/*', type: :shell)    .should be == '**/*'                }
+    example { utils.glob_pattern(/can't parse this/)      .should be == '**/*'                }
+    example { utils.glob_pattern('/foo', type: :identity) .should be == '/foo'                }
+    example { utils.glob_pattern('/fo*', type: :identity) .should be == '/fo\\*'              }
+  end
+  describe :glob do
+    example do
+      utils.glob(":name.txt").sort.should be == ['bar.txt', 'foo.txt']
+    end
+    example do
+      extensions = []
+      utils.glob("foo.:ext") { |file, params| extensions << params['ext'] }
+      extensions.sort.should be == ['rb', 'txt']
+    end
+    example do
+      utils.glob(":name.:ext", capture: { ext: 'rb', name: 'foo' }).should be == ['foo.rb']
+    end
+  end
+  describe :glob_map do
+    example do
+      utils.glob_map(':name.rb' => ':name/init.rb').should be == {
+        "bar.rb" => "bar/init.rb",
+        "foo.rb" => "foo/init.rb"
+      }
+    end
+    example do
+      result   = {}
+      returned = utils.glob_map(':name.rb' => ':name/init.rb') { |k, v| result[v] = k.upcase }
+      returned.sort         .should be == ["BAR.RB", "FOO.RB"]
+      result["bar/init.rb"] .should be == "BAR.RB"
+    end
+  end
+  describe :cp do
+    example do
+      utils.cp(':name.rb' => ':name.ruby', ':name.txt' => ':name.md')
+      File.should be_exist('foo.ruby')
+      File.should be_exist('bar.md')
+      File.should be_exist('bar.txt')
+    end
+  end
+  describe :cp_r do
+    example do
+      mkdir_p "foo/bar"
+      utils.cp_r('foo/:name' => :name)
+      File.should be_directory('bar')
+    end
+  end
+  describe :mv do
+    example do
+      utils.mv(':name.rb' => ':name.ruby', ':name.txt' => ':name.md')
+      File.should     be_exist('foo.ruby')
+      File.should     be_exist('bar.md')
+      File.should_not be_exist('bar.txt')
+    end
+  end
+  describe :ln do
+    example do
+      utils.ln(':name.rb' => ':name.ruby', ':name.txt' => ':name.md')
+      File.should be_exist('foo.ruby')
+      File.should be_exist('bar.md')
+      File.should be_exist('bar.txt')
+    end
+  end
+  describe :ln_s do
+    example do
+      utils.ln_s(':name.rb' => ':name.ruby', ':name.txt' => ':name.md')
+      File.should be_symlink('foo.ruby')
+      File.should be_symlink('bar.md')
+      File.should be_exist('bar.txt')
+    end
+  end
+  describe :ln_sf do
+    example do
+      utils.ln_sf(':name.rb' => ':name.txt')
+      File.should be_symlink('foo.txt')
+    end
+  end
+end

metadata ADDED

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification
+name: mustermann-fileutils
+version: !ruby/object:Gem::Version
+  version: 0.4.0
+platform: ruby
+authors:
+- Konstantin Haase
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2014-11-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mustermann
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.4.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.4.0
+description: Operate efficiently on your file system using Mustermann
+email: konstantin.mailinglists@googlemail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/mustermann/file_utils.rb
+- lib/mustermann/file_utils/glob_pattern.rb
+- lib/mustermann/fileutils.rb
+- mustermann-fileutils.gemspec
+- spec/file_utils_spec.rb
+homepage: https://github.com/rkh/mustermann
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project:
+rubygems_version: 2.4.3
+signing_key:
+specification_version: 4
+summary: File Utils for Mustermann
+test_files:
+- spec/file_utils_spec.rb
+has_rdoc: