mustermann-fileutils 0.4.0

checksums.yaml

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

data/README.md

@@ -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

@@ -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

@@ -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

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

data/mustermann-fileutils.gemspec

@@ -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

@@ -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

@@ -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: