shellwords 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: de57cbc9a6fe3cf8c17e930e43f602c3bc7a0166b22dac8f9135a51bf8d8ef7a
+  data.tar.gz: b9cd1182e3b09befea06b84c5a75407a4a1d4d008d1a0ac8fd9c32804f4cb046
+SHA512:
+  metadata.gz: f1ef0d09c787850785c82ad87b591a59788ffa97bf29d740079d80702e432dd50718ba8bb811637602600eedd38c037b913bdc08eb0deecc98bbc2140caf119c
+  data.tar.gz: 72e8753f7f9b851c8373771beb450e628a48ea549476c8877a94e1e2859142cbf626a6c73dc73a6ac9a0f98b5a7bda26a4a127eb1086eb3f8921c53bd08cd5a0

data/.github/workflows/test.yml

@@ -0,0 +1,24 @@
+name: test
+
+on: [push, pull_request]
+
+jobs:
+  build:
+    name: build (${{ matrix.ruby }} / ${{ matrix.os }})
+    strategy:
+      matrix:
+        ruby: [ 2.7, 2.6, 2.5, head ]
+        os: [ ubuntu-latest, macos-latest ]
+    runs-on: ${{ matrix.os }}
+    steps:
+    - uses: actions/checkout@master
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby }}
+    - name: Install dependencies
+      run: |
+        gem install bundler --no-document
+        bundle install
+    - name: Run test
+      run: rake test

data/.gitignore

@@ -0,0 +1,8 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+gem "rake"
+gem "test-unit"

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (C) 1993-2013 Yukihiro Matsumoto. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+1. Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGE.

data/README.md

@@ -0,0 +1,46 @@
+# Shellwords
+
+This module manipulates strings according to the word parsing rules
+of the UNIX Bourne shell.
+
+The shellwords() function was originally a port of shellwords.pl,
+but modified to conform to the Shell & Utilities volume of the IEEE
+Std 1003.1-2008, 2016 Edition [1].
+
+[1] [IEEE Std 1003.1-2008, 2016 Edition, the Shell & Utilities volume](http://pubs.opengroup.org/onlinepubs/9699919799/utilities/contents.html)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'shellwords'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install shellwords
+
+## Usage
+
+```ruby
+require 'shellwords'
+
+argv = Shellwords.split('three blind "mice"')
+argv #=> ["three", "blind", "mice"]
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/ruby/shellwords.
+

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/test_*.rb"]
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "shellwords"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/shellwords.rb

@@ -0,0 +1,240 @@
+# frozen-string-literal: true
+##
+# == Manipulates strings like the UNIX Bourne shell
+#
+# This module manipulates strings according to the word parsing rules
+# of the UNIX Bourne shell.
+#
+# The shellwords() function was originally a port of shellwords.pl,
+# but modified to conform to the Shell & Utilities volume of the IEEE
+# Std 1003.1-2008, 2016 Edition [1].
+#
+# === Usage
+#
+# You can use Shellwords to parse a string into a Bourne shell friendly Array.
+#
+#   require 'shellwords'
+#
+#   argv = Shellwords.split('three blind "mice"')
+#   argv #=> ["three", "blind", "mice"]
+#
+# Once you've required Shellwords, you can use the #split alias
+# String#shellsplit.
+#
+#   argv = "see how they run".shellsplit
+#   argv #=> ["see", "how", "they", "run"]
+#
+# They treat quotes as special characters, so an unmatched quote will
+# cause an ArgumentError.
+#
+#   argv = "they all ran after the farmer's wife".shellsplit
+#        #=> ArgumentError: Unmatched quote: ...
+#
+# Shellwords also provides methods that do the opposite.
+# Shellwords.escape, or its alias, String#shellescape, escapes
+# shell metacharacters in a string for use in a command line.
+#
+#   filename = "special's.txt"
+#
+#   system("cat -- #{filename.shellescape}")
+#   # runs "cat -- special\\'s.txt"
+#
+# Note the '--'.  Without it, cat(1) will treat the following argument
+# as a command line option if it starts with '-'.  It is guaranteed
+# that Shellwords.escape converts a string to a form that a Bourne
+# shell will parse back to the original string, but it is the
+# programmer's responsibility to make sure that passing an arbitrary
+# argument to a command does no harm.
+#
+# Shellwords also comes with a core extension for Array, Array#shelljoin.
+#
+#   dir = "Funny GIFs"
+#   argv = %W[ls -lta -- #{dir}]
+#   system(argv.shelljoin + " | less")
+#   # runs "ls -lta -- Funny\\ GIFs | less"
+#
+# You can use this method to build a complete command line out of an
+# array of arguments.
+#
+# === Authors
+# * Wakou Aoyama
+# * Akinori MUSHA <knu@iDaemons.org>
+#
+# === Contact
+# * Akinori MUSHA <knu@iDaemons.org> (current maintainer)
+#
+# === Resources
+#
+# 1: {IEEE Std 1003.1-2008, 2016 Edition, the Shell & Utilities volume}[http://pubs.opengroup.org/onlinepubs/9699919799/utilities/contents.html]
+
+module Shellwords
+  # Splits a string into an array of tokens in the same way the UNIX
+  # Bourne shell does.
+  #
+  #   argv = Shellwords.split('here are "two words"')
+  #   argv #=> ["here", "are", "two words"]
+  #
+  # Note, however, that this is not a command line parser.  Shell
+  # metacharacters except for the single and double quotes and
+  # backslash are not treated as such.
+  #
+  #   argv = Shellwords.split('ruby my_prog.rb | less')
+  #   argv #=> ["ruby", "my_prog.rb", "|", "less"]
+  #
+  # String#shellsplit is a shortcut for this function.
+  #
+  #   argv = 'here are "two words"'.shellsplit
+  #   argv #=> ["here", "are", "two words"]
+  def shellsplit(line)
+    words = []
+    field = String.new
+    line.scan(/\G\s*(?>([^\s\\\'\"]+)|'([^\']*)'|"((?:[^\"\\]|\\.)*)"|(\\.?)|(\S))(\s|\z)?/m) do
+      |word, sq, dq, esc, garbage, sep|
+      raise ArgumentError, "Unmatched quote: #{line.inspect}" if garbage
+      # 2.2.3 Double-Quotes:
+      #
+      #   The <backslash> shall retain its special meaning as an
+      #   escape character only when followed by one of the following
+      #   characters when considered special:
+      #
+      #   $ ` " \ <newline>
+      field << (word || sq || (dq && dq.gsub(/\\([$`"\\\n])/, '\\1')) || esc.gsub(/\\(.)/, '\\1'))
+      if sep
+        words << field
+        field = String.new
+      end
+    end
+    words
+  end
+
+  alias shellwords shellsplit
+
+  module_function :shellsplit, :shellwords
+
+  class << self
+    alias split shellsplit
+  end
+
+  # Escapes a string so that it can be safely used in a Bourne shell
+  # command line.  +str+ can be a non-string object that responds to
+  # +to_s+.
+  #
+  # Note that a resulted string should be used unquoted and is not
+  # intended for use in double quotes nor in single quotes.
+  #
+  #   argv = Shellwords.escape("It's better to give than to receive")
+  #   argv #=> "It\\'s\\ better\\ to\\ give\\ than\\ to\\ receive"
+  #
+  # String#shellescape is a shorthand for this function.
+  #
+  #   argv = "It's better to give than to receive".shellescape
+  #   argv #=> "It\\'s\\ better\\ to\\ give\\ than\\ to\\ receive"
+  #
+  #   # Search files in lib for method definitions
+  #   pattern = "^[ \t]*def "
+  #   open("| grep -Ern -e #{pattern.shellescape} lib") { |grep|
+  #     grep.each_line { |line|
+  #       file, lineno, matched_line = line.split(':', 3)
+  #       # ...
+  #     }
+  #   }
+  #
+  # It is the caller's responsibility to encode the string in the right
+  # encoding for the shell environment where this string is used.
+  #
+  # Multibyte characters are treated as multibyte characters, not as bytes.
+  #
+  # Returns an empty quoted String if +str+ has a length of zero.
+  def shellescape(str)
+    str = str.to_s
+
+    # An empty argument will be skipped, so return empty quotes.
+    return "''".dup if str.empty?
+
+    str = str.dup
+
+    # Treat multibyte characters as is.  It is the caller's responsibility
+    # to encode the string in the right encoding for the shell
+    # environment.
+    str.gsub!(/[^A-Za-z0-9_\-.,:+\/@\n]/, "\\\\\\&")
+
+    # A LF cannot be escaped with a backslash because a backslash + LF
+    # combo is regarded as a line continuation and simply ignored.
+    str.gsub!(/\n/, "'\n'")
+
+    return str
+  end
+
+  module_function :shellescape
+
+  class << self
+    alias escape shellescape
+  end
+
+  # Builds a command line string from an argument list, +array+.
+  #
+  # All elements are joined into a single string with fields separated by a
+  # space, where each element is escaped for the Bourne shell and stringified
+  # using +to_s+.
+  #
+  #   ary = ["There's", "a", "time", "and", "place", "for", "everything"]
+  #   argv = Shellwords.join(ary)
+  #   argv #=> "There\\'s a time and place for everything"
+  #
+  # Array#shelljoin is a shortcut for this function.
+  #
+  #   ary = ["Don't", "rock", "the", "boat"]
+  #   argv = ary.shelljoin
+  #   argv #=> "Don\\'t rock the boat"
+  #
+  # You can also mix non-string objects in the elements as allowed in Array#join.
+  #
+  #   output = `#{['ps', '-p', $$].shelljoin}`
+  #
+  def shelljoin(array)
+    array.map { |arg| shellescape(arg) }.join(' ')
+  end
+
+  module_function :shelljoin
+
+  class << self
+    alias join shelljoin
+  end
+end
+
+class String
+  # call-seq:
+  #   str.shellsplit => array
+  #
+  # Splits +str+ into an array of tokens in the same way the UNIX
+  # Bourne shell does.
+  #
+  # See Shellwords.shellsplit for details.
+  def shellsplit
+    Shellwords.split(self)
+  end
+
+  # call-seq:
+  #   str.shellescape => string
+  #
+  # Escapes +str+ so that it can be safely used in a Bourne shell
+  # command line.
+  #
+  # See Shellwords.shellescape for details.
+  def shellescape
+    Shellwords.escape(self)
+  end
+end
+
+class Array
+  # call-seq:
+  #   array.shelljoin => string
+  #
+  # Builds a command line string from an argument list +array+ joining
+  # all elements escaped for the Bourne shell and separated by a space.
+  #
+  # See Shellwords.shelljoin for details.
+  def shelljoin
+    Shellwords.join(self)
+  end
+end

data/shellwords.gemspec

@@ -0,0 +1,22 @@
+Gem::Specification.new do |spec|
+  spec.name          = "shellwords"
+  spec.version       = "0.1.0"
+  spec.authors       = ["Akinori MUSHA"]
+  spec.email         = ["knu@idaemons.org"]
+
+  spec.summary       = %q{Manipulates strings with word parsing rules of UNIX Bourne shell.}
+  spec.description   = %q{Manipulates strings with word parsing rules of UNIX Bourne shell.}
+  spec.homepage      = "https://github.com/ruby/shellwords"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.3.0")
+  spec.licenses      = ["Ruby", "BSD-2-Clause"]
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+end

metadata

@@ -0,0 +1,56 @@
+--- !ruby/object:Gem::Specification
+name: shellwords
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Akinori MUSHA
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2020-09-18 00:00:00.000000000 Z
+dependencies: []
+description: Manipulates strings with word parsing rules of UNIX Bourne shell.
+email:
+- knu@idaemons.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/workflows/test.yml"
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/shellwords.rb
+- shellwords.gemspec
+homepage: https://github.com/ruby/shellwords
+licenses:
+- Ruby
+- BSD-2-Clause
+metadata:
+  homepage_uri: https://github.com/ruby/shellwords
+  source_code_uri: https://github.com/ruby/shellwords
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key:
+specification_version: 4
+summary: Manipulates strings with word parsing rules of UNIX Bourne shell.
+test_files: []