unicopy 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b52015a55845441084cce91c2820e7faa888078b
+  data.tar.gz: e23151d662fac4f0c811748fc5b1be0c4a451637
+SHA512:
+  metadata.gz: b40c34ec4178cb320a175f3ad4a716539f167882a251281a6f0320fe0db970d8246048109eca0e95d467187c2bcb160fed8c74ef3dad519dc0fb4c78d9338df1
+  data.tar.gz: a8d21e068ea34e19668e09129884def732ea387002defab2870d2696ece52eff01eb4e115099ef3d9ed3d66027669714584924821f883f9355a04f3ee5c64012

data/.gitignore

@@ -0,0 +1,2 @@
+Gemfile.lock
+/pkg

data/.travis.yml

@@ -0,0 +1,22 @@
+sudo: false
+language: ruby
+
+rvm:
+- ruby-head
+- 2.4.1
+- 2.3.4
+- 2.2
+- 2.1
+- 2.0
+- jruby-head
+- jruby-9.1.8.0
+
+cache:
+- bundler
+
+matrix:
+  allow_failures:
+    - rvm: jruby-head
+    - rvm: ruby-head
+    - rvm: 2.0
+#   fast_finish: true

data/CHANGELOG.md

@@ -0,0 +1,67 @@
+## CHANGELOG
+
+### 2.4.0
+
+* Extract symbolification logic into extra [symbolify](https://github.com/janlelis/symbolify) gem (includes fixes and non-character detection)
+* Update characteristics gem (includes a new blank)
+
+### 2.3.0
+
+* More consistent handling of bidi controls (always symbolify with alias, but highlight ALM, RLM, LRM as blanks)
+* Highlight control chars that are also blanks as blank
+* Highlight CGJ as blank
+* Highlight NEL as blank (only in Unicode)
+* Add Unicode version to `unibits --version` command
+
+### 2.2.0
+
+* Add mongolian free variation selectors and combining grapheme joiner to interesting codepoints list
+* Green highlighting of "marks" in Unicode
+* Always use dotted circle for non-spacing marks
+* Always prepend enclosing marks with a space
+* Update characteristics gem (includes new blanks and UTF-8 dialects with japanese emojis)
+
+### 2.1.1
+
+* Proper UTF-32 validness / invalid codepoint highlighting, see https://bugs.ruby-lang.org/issues/13292
+
+### 2.1.0
+
+* Support more encoding: IBMX, CP85X, macX, TIS-620/Windows-874, and KOI8-X
+* Highlight non-control formatting characters in pink
+* Improve `unibits --help` command
+
+### 2.0.0
+
+* Support more encodings: ISO-8859-X and Windows-125X
+* Add three HANGUL characters (U+115F, U+1160, U+3164) to list of possible white spaces
+* Move character handling to separate gem. It is called [characteristics](https://github.com/janlelis/characteristics).
+* Highlight control chars in blue and blanks in light blue
+* Handle encodings that are not convertible to UTF-8
+
+### 1.3.0
+
+* Add variation selectors 17-256 (U+E0100 - U+E01EF)
+* Add U+1D159 (MUSICAL SYMBOL NULL NOTEHEAD) to list of possible white spaces
+* Bump unicode-categories dependency for more reliable unassigned codepoint detection
+
+### 1.2.1
+
+* Fix bug that inserted wrong bytes
+
+### 1.2.0
+
+* Do not display (but highlight) unassigned codepoints
+
+### 1.1.0
+
+* Support (and highlight) invalid encodings \o/
+* Improve character symbolification
+* Fix that the Kernel method would not take keyword arguments
+* New option for setting a custom output width to use
+* New option for activating wide ambiguous characters
+
+### 1.0.0
+
+* Initial release
+

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,74 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at opensource@janlelis.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+gemspec
+
+gem 'minitest'
+gem 'rake'
+gem 'irbtools', require: 'irbtools/binding'

data/MIT-LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2017 Jan Lelis, mail@janlelis.de
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,188 @@
+# unicopy [![[version]](https://badge.fury.io/rb/unicopy.svg)](http://badge.fury.io/rb/unicopy)  [![[travis]](https://travis-ci.org/janlelis/unicopy.svg)](https://travis-ci.org/janlelis/unicopy)
+
+CLI utility which converts Unicode codepoints to a string (or vice versa). Copies the result to the system clipboard or just prints it to the console.
+
+Can also convert codepoints to many dump formats.
+
+## Setup
+
+Make sure you have Ruby installed and installing gems works properly. Then do:
+
+```
+$ gem install unicopy
+```
+
+## Usage
+
+### Codepoints to String
+
+Codepoints format is hexadecimal, "U+" is permitted, examples:
+
+```ruby
+$ unicopy 52 75 62 79 --print
+Ruby
+```
+
+```ruby
+$ unicopy U+0052 U+0075 U+0062 U+0079 --print
+Ruby
+```
+
+### String to Codepoints
+
+```ruby
+$ unicopy --string Ruby --print
+U+0052 U+0075 U+0062 U+0079
+```
+
+### Options
+
+```
+--help                |    | this help page
+--parse-decimal       |    | interpret given codepoints as decimal, instead of hexadecimal values
+--print               | -p | do not copy to system clipboard, but print to screen
+--string              | -s | see above
+--version             |    | displays version of unicopy
+--(dump format)       |    | specify the format to be used for dumping the codepoints (see below)
+```
+
+### Dump Formats
+
+#### Short Hexadecimal
+
+```
+$ unicopy 52 75 62 79 20 1F32B --print --hex
+52 75 62 79 20 1F32B
+```
+
+```
+$ unicopy --string "Ruby 🌫" --print --hex
+52 75 62 79 20 1F32B
+```
+
+#### Hexadecimal With `U+` Prefix
+
+```
+$ unicopy 52 75 62 79 20 1F32B --print --uplus
+U+0052 U+0075 U+0062 U+0079 U+0020 U+1F32B
+```
+
+```
+$ unicopy --string "Ruby 🌫" --print --uplus
+U+0052 U+0075 U+0062 U+0079 U+0020 U+1F32B
+```
+
+#### Hexadecimal With `0x` Prefix
+
+```
+$ unicopy 52 75 62 79 20 1F32B --print --0x
+0x0052 0x0075 0x0062 0x0079 0x0020 0x1F32B
+```
+
+```
+$ unicopy --string "Ruby 🌫" --print --0x
+0x0052 0x0075 0x0062 0x0079 0x0020 0x1F32B
+```
+
+#### Decimal
+
+```
+$ unicopy 52 75 62 79 20 1F32B --print --dec
+82 117 98 121 32 127787
+```
+
+```
+$ unicopy --string "Ruby 🌫" --print --dec
+82 117 98 121 32 127787
+```
+
+#### Ruby Escape Syntax
+
+```
+$ unicopy 52 75 62 79 20 1F32B --print --ruby
+\\u{52 75 62 79 20 1F32B}
+```
+
+```
+$ unicopy --string "Ruby 🌫" --print --ruby
+\\u{52 75 62 79 20 1F32B}
+```
+
+#### JavaScript Escape Syntax (Since ES6)
+
+```
+$ unicopy 52 75 62 79 20 1F32B --print --es6
+\\u{52}\\u{75}\\u{62}\\u{79}\\u{20}\\u{1F32B}
+```
+
+```
+$ unicopy --string "Ruby 🌫" --print --es6
+\\u{52}\\u{75}\\u{62}\\u{79}\\u{20}\\u{1F32B}
+```
+
+#### JavaScript Escape Syntax (Before ES6)
+
+```
+$ unicopy 52 75 62 79 20 1F32B --print --js
+\\u0052\\u0075\\u0062\\u0079\\u0020\\uD83C\\uDF2B
+```
+
+```
+$ unicopy --string "Ruby 🌫" --print --js
+\\u0052\\u0075\\u0062\\u0079\\u0020\\uD83C\\uDF2B
+```
+
+#### CSS Escape Syntax
+
+```
+$ unicopy 52 75 62 79 20 1F32B --print --css
+\\52\\75\\62\\79\\20\\1f32b
+```
+
+```
+$ unicopy --string "Ruby 🌫" --print --css
+\\52\\75\\62\\79\\20\\1f32b
+```
+
+#### Hexadecimal HTML Entities
+
+```
+$ unicopy 52 75 62 79 20 1F32B --print --html-hex
+Ruby 🌫
+```
+
+```
+$ unicopy --string "Ruby 🌫" --print --html-hex
+Ruby 🌫
+```
+
+#### Decimal HTML Entities
+
+```
+$ unicopy 52 75 62 79 20 1F32B --print --html-dec
+Ruby 🌫
+```
+
+```
+$ unicopy --string "Ruby 🌫" --print --html-dec
+Ruby 🌫
+```
+
+#### UTF-8 in Hexadecimal Bytes
+
+```
+$ unicopy 52 75 62 79 20 1F32B --print --bytes-utf8
+52 75 62 79 20 F0 9F 8C AB
+```
+
+```
+$ unicopy --string "Ruby 🌫" --print --bytes-utf8
+52 75 62 79 20 F0 9F 8C AB
+```
+
+## Also see
+
+- [unibits](https://github.com/janlelis/unibits)
+- [uniscribe](https://github.com/janlelis/uniscribe)
+
+Copyright (C) 2017 Jan Lelis <http://janlelis.com>. Released under the MIT license.

data/Rakefile

@@ -0,0 +1,38 @@
+# # #
+# Get gemspec info
+
+gemspec_file = Dir['*.gemspec'].first
+gemspec = eval File.read(gemspec_file), binding, gemspec_file
+info = "#{gemspec.name} | #{gemspec.version} | " \
+       "#{gemspec.runtime_dependencies.size} dependencies | " \
+       "#{gemspec.files.size} files"
+
+# # #
+# Gem build and install task
+
+desc info
+task :gem do
+  puts info + "\n\n"
+  print "  "; sh "gem build #{gemspec_file}"
+  FileUtils.mkdir_p 'pkg'
+  FileUtils.mv "#{gemspec.name}-#{gemspec.version}.gem", 'pkg'
+  puts; sh %{gem install --no-document pkg/#{gemspec.name}-#{gemspec.version}.gem}
+end
+
+# # #
+# Start an IRB session with the gem loaded
+
+desc "#{gemspec.name} | IRB"
+task :irb do
+  sh "irb -I ./lib -r #{gemspec.name.gsub '-','/'}/kernel_method"
+end
+
+# # #
+# Run specs
+
+desc "#{gemspec.name} | Spec"
+task :spec do
+  sh "for file in spec/*_spec.rb; do ruby $file; done"
+end
+task default: :spec
+

data/bin/unicopy

@@ -0,0 +1,184 @@
+#!/usr/bin/env ruby
+
+require "rationalist"
+require "paint"
+require "unicopy"
+
+argv = Rationalist.parse(
+  ARGV,
+  string: '_',
+  alias: {
+    p: 'print',
+    s: 'string',
+    v: 'version',
+  }.merge(Hash[Unicopy::DUMP_FORMATS.select{ |k,v| v[:alias] }.map{ |k,v| [v[:alias], k] }]),
+  boolean: [
+    'parse-decimal',
+    'help',
+    'print',
+    'string',
+    'version',
+    *Unicopy::DUMP_FORMATS.keys
+  ]
+)
+
+if argv[:version]
+  puts "unicopy #{Unicopy::VERSION} by #{Paint["J-_-L", :bold]} <https://github.com/janlelis/unicopy>"
+  exit(0)
+end
+
+
+if argv[:help]
+dump_format_description = Unicopy::DUMP_FORMATS.map{ |dump_format, info|
+  "--#{dump_format.ljust(20)}| #{info[:alias] ? "-#{info[:alias]}" : "  "} | #{info[:description]}"
+}.join("\n  ")
+
+  puts <<-HELP
+
+  #{Paint["DESCRIPTION", :underline]}
+
+  Converts Unicode codepoints to a string (or vice versa) and copies it to the system clipboard.
+  Can also convert codepoints to many dump formats.
+
+  #{Paint["USAGE", :underline]}
+
+  CODEPOINTS TO STRING
+
+  #{Paint["unicopy", :bold]} [options] codepoints
+
+  Codepoints format is hexadecimal, "U+" is permitted, examples:
+
+  $ unicopy 52 75 62 79 20 1F32B --print
+  Ruby 🌫
+
+  $ unicopy U+0052 U+0075 U+0062 U+0079 U+0020 U+1F32B --print
+  Ruby 🌫
+
+  STRING TO CODEPOINTS
+
+  #{Paint["unicopy", :bold]} (--string|-s) [options] string
+
+  $ unicopy -sp "Ruby 🌫"
+  U+0052 U+0075 U+0062 U+0079 U+0020 U+1F32B
+
+  If data is retrieved via STDIN, it will split alongside newlines.
+
+  #{Paint["OPTIONS", :underline]}
+
+  --help                |    | this help page
+  --parse-decimal       |    | interpret given codepoints as decimal, instead of hexadecimal values
+  --print               | -p | do not copy to system clipboard, but print to screen
+  --string              | -s | see above
+  --version             |    | displays version of unicopy
+  --(dump format)       |    | specify the format to be used for dumping the codepoints (see below)
+
+  #{Paint["DUMP FORMATS", :underline]}
+
+  #{dump_format_description}
+
+  Examples:
+
+  $ unicopy 52 75 62 79 20 1F32B --print --hex
+  52 75 62 79 20 1F32B
+
+  $ unicopy --string "Ruby 🌫" --print --hex
+  52 75 62 79 20 1F32B
+
+  $ unicopy 52 75 62 79 20 1F32B --print --uplus
+  U+0052 U+0075 U+0062 U+0079 U+0020 U+1F32B
+
+  $ unicopy --string "Ruby 🌫" --print --uplus
+  U+0052 U+0075 U+0062 U+0079 U+0020 U+1F32B
+
+  $ unicopy 52 75 62 79 20 1F32B --print --0x
+  0x0052 0x0075 0x0062 0x0079 0x0020 0x1F32B
+
+  $ unicopy --string "Ruby 🌫" --print --0x
+  0x0052 0x0075 0x0062 0x0079 0x0020 0x1F32B
+
+  $ unicopy 52 75 62 79 20 1F32B --print --dec
+  82 117 98 121 32 127787
+
+  $ unicopy --string "Ruby 🌫" --print --dec
+  82 117 98 121 32 127787
+
+  $ unicopy 52 75 62 79 20 1F32B --print --ruby
+  \\u{52 75 62 79 20 1F32B}
+
+  $ unicopy --string "Ruby 🌫" --print --ruby
+  \\u{52 75 62 79 20 1F32B}
+
+  $ unicopy 52 75 62 79 20 1F32B --print --js
+  \\u0052\\u0075\\u0062\\u0079\\u0020\\uD83C\\uDF2B
+
+  $ unicopy --string "Ruby 🌫" --print --js
+  \\u0052\\u0075\\u0062\\u0079\\u0020\\uD83C\\uDF2B
+
+  $ unicopy 52 75 62 79 20 1F32B --print --es6
+  \\u{52}\\u{75}\\u{62}\\u{79}\\u{20}\\u{1F32B}
+
+  $ unicopy --string "Ruby 🌫" --print --es6
+  \\u{52}\\u{75}\\u{62}\\u{79}\\u{20}\\u{1F32B}
+
+  $ unicopy 52 75 62 79 20 1F32B --print --css
+  \\52\\75\\62\\79\\20\\1f32b
+
+  $ unicopy --string "Ruby 🌫" --print --css
+  \\52\\75\\62\\79\\20\\1f32b
+
+  $ unicopy 52 75 62 79 20 1F32B --print --html-hex
+  &#x52;&#x75;&#x62;&#x79;&#x20;&#x1F32B;
+
+  $ unicopy --string "Ruby 🌫" --print --html-hex
+  &#x52;&#x75;&#x62;&#x79;&#x20;&#x1F32B;
+
+  $ unicopy 52 75 62 79 20 1F32B --print --html-dec
+  &#82;&#117;&#98;&#121;&#32;&#127787;
+
+  $ unicopy --string "Ruby 🌫" --print --html-dec
+  &#82;&#117;&#98;&#121;&#32;&#127787;
+
+  $ unicopy 52 75 62 79 20 1F32B --print --bytes-utf8
+  52 75 62 79 20 F0 9F 8C AB
+
+  $ unicopy --string "Ruby 🌫" --print --bytes-utf8
+  52 75 62 79 20 F0 9F 8C AB
+
+  #{Paint["MORE INFO", :underline]}
+
+  https://github.com/janlelis/unicopy
+
+  HELP
+  exit(0)
+end
+
+if argv[:_]
+  codepoints = argv.delete :_
+elsif !$stdin.tty?
+  codepoints = $stdin.read.split($/)
+else
+  codepoints = nil
+end
+
+options = {
+  parse_decimal: argv[:"parse-decimal"],
+  print:   argv[:print],
+  string:  argv[:string],
+}
+
+dump_formats = Unicopy::DUMP_FORMATS.keys.select{ |dump_format| argv[dump_format.to_sym] }
+case dump_formats.size
+when 0
+  # nothing
+when 1
+  options[:dump] = dump_formats[0]
+else
+  raise ArgumentError, "only one dump format can be passed to unicopy"
+end
+
+begin
+  Unicopy.unicopy(*codepoints, **options)
+rescue ArgumentError
+  $stderr.puts Paint[$!.message, :red]
+  exit(1)
+end

data/lib/unicopy.rb

@@ -0,0 +1,143 @@
+# enable-frozen-string: true
+
+require_relative "unicopy/version"
+
+require "clipboard"
+
+module Unicopy
+  DUMP_FORMATS = {
+    'hex' => {
+      description: "____ (hexadecimal)",
+      replace: "%X",
+      alias: "x",
+    },
+    'uplus' => {
+      description: "U+____ (hexadecimal)",
+      replace: "U+%04X",
+      alias: "u",
+    },
+    '0x' => {
+      description: "0x____ (hexadecimal)",
+      replace: "0x%04X",
+      alias: "0",
+    },
+    'dec' => {
+      description: "____ (decimal)",
+      replace: "%d",
+      alias: "d",
+    },
+    'ruby' => {
+      description: "Ruby \\u{____} (hexadecimal)",
+      prefix: "\\u{",
+      replace: "%X",
+      suffix: "}",
+      alias: "r",
+    },
+    'css' => {
+      description: "CSS \\____ (hexadecimal)",
+      replace: "\\%x",
+      joiner: "",
+      suffix: " ",
+    },
+    'js' => {
+      description: "JavaScript \\u____ with UTF-16 surrogates (hexadecimal)",
+      replace: ->(x){
+        [x].pack("U").encode("UTF-16BE").each_byte.each_slice(2).map{ |a,b| "\\u%04X" % (a*256 + b) }
+      },
+      joiner: "",
+    },
+    'es6' => {
+      description: "EcmaScript 6+ \\u{____} (hexadecimal)",
+      replace: "\\u{%X}",
+      joiner: "",
+      alias: "6",
+    },
+    'html-hex' => {
+      description: "HTML entitiy &#x____ (hexadecimal)",
+      replace: "&#x%X;",
+      joiner: "",
+    },
+    'html-dec' => {
+      description: "HTML entitiy &#____ (decimal)",
+      replace: "&#%d;",
+      joiner: "",
+    },
+    'bytes-utf8' => {
+      description: "UTF-8 encoded (bytes)",
+      replace: ->(x){
+        [x].pack("U").unpack("C*").map{ |x| x.to_s(16).upcase }.join(" ")
+      },
+    }
+  }
+  DUMP_FORMAT_DEFAULTS = {
+    prefix: "",
+    replace: "%s",
+    joiner: " ",
+    suffix: "",
+  }
+
+  def self.unicopy(*args, string: false, dump: nil, parse_decimal: false, print: false)
+    if args.empty?
+      raise ArgumentError, "no data given to copy"
+    elsif !string
+      codepoints = transform_raw_codepoints(args.join(" ").split(" "), parse_decimal)
+      if dump
+        deliver(dump_codepoints(codepoints, format: dump), print: print, codepoints_length: codepoints.length, message: "dump of")
+      else # default
+        deliver(codepoints.pack("U*"), print: print, codepoints_length: codepoints.length, message: "string of")
+      end
+    else
+      data = args.join("")
+      data = data.encode("UTF-8") unless data.encoding.name == "UTF-8"
+      codepoints = data.unpack("U*")
+
+      deliver(dump_codepoints(codepoints, format: dump), print: print, codepoints_length: codepoints.length, message: "dump of")
+    end
+  end
+
+  def self.deliver(output, print: false, message: "", codepoints_length:)
+    if print
+      puts(output)
+    else
+      Clipboard.copy(output)
+      puts Paint["Copied #{message} #{codepoints_length} codepoint#{codepoints_length != 1 ? "s" : ""} to clipboard", :green]
+    end
+  end
+
+  def self.transform_raw_codepoints(codepoints, parse_decimal = false)
+    if parse_decimal
+      parse_numerals_regex = /\A([0-9]+)\z/
+      numeral_base = 10
+    else
+      parse_numerals_regex = /\A(?:U\+)?(\h+)\z/
+      numeral_base = 16
+    end
+
+    codepoints.map{ |cp|
+      case cp
+      when Integer
+        cp
+      when parse_numerals_regex
+        $1.to_i(numeral_base)
+      else
+        raise ArgumentError, "unicopy does not understand codepoint \"#{cp}\". Please pass hexadecimal codepoint values, separated by spaces, or use --string option"
+      end
+    }.tap{ |codepoints|
+      codepoints.pack("U*").valid_encoding? or raise ArgumentError, "invalid codepoints passed to unicopy"
+    }
+  end
+
+  def self.dump_codepoints(codepoints, format: nil)
+    format ||= "uplus"
+    if dump_format_details = DUMP_FORMATS[format]
+      prefix  = dump_format_details[:prefix]  || DUMP_FORMAT_DEFAULTS[:prefix]
+      replace = dump_format_details[:replace] || DUMP_FORMAT_DEFAULTS[:replace]
+      joiner  = dump_format_details[:joiner]  || DUMP_FORMAT_DEFAULTS[:joiner]
+      suffix  = dump_format_details[:suffix]  || DUMP_FORMAT_DEFAULTS[:suffix]
+    else
+      raise ArgumentError, "unicopy does not know dump format \"#{format}\""
+    end
+
+    prefix + codepoints.map{ |cp| replace.is_a?(Proc) ? replace[cp] : replace % cp }.join(joiner) + suffix
+  end
+end

data/lib/unicopy/kernel_method.rb

@@ -0,0 +1,9 @@
+require_relative '../unicopy'
+
+module Kernel
+  private
+
+  def unicopy(string, **kwargs)
+    Unicopy.unicopy(string, **kwargs)
+  end
+end

data/lib/unicopy/version.rb

@@ -0,0 +1,3 @@
+module Unicopy
+  VERSION = "1.0.0".freeze
+end

data/spec/unicopy_spec.rb

@@ -0,0 +1,102 @@
+require_relative "../lib/unicopy/kernel_method"
+require "minitest/autorun"
+
+describe Unicopy do
+  it "converts codepoints to string and, with --print, outputs it to STDOUT" do
+    assert_output(/Ruby 🌫/){ unicopy("52 75 62 79 20 1F32B", print: true) }
+  end
+
+  it "also works with U+ prefixes" do
+    assert_output(/Ruby 🌫/){ unicopy("U+0052 U+0075 U+0062 U+0079 U+0020 U+1F32B", print: true) }
+  end
+
+  it "parses codepoints as decimal if --parse-decimal option is given" do
+    assert_output(/4K>O/){ unicopy("52 75 62 79", print: true, parse_decimal: true) }
+  end
+
+  it "will convert string to codepoints with --string option" do
+    assert_output(Regexp.compile(Regexp.escape("U+0052 U+0075 U+0062 U+0079 U+0020 U+1F32B"))){
+      unicopy("Ruby 🌫", print: true, string: true)
+    }
+  end
+
+  it "works with non-UTF-8 input" do
+    assert_output(Regexp.compile(Regexp.escape("U+0052 U+0075 U+0062 U+0079 U+0020 U+1F32B"))){
+      unicopy("Ruby 🌫".encode("UTF-16LE"), print: true, string: true)
+    }
+  end
+
+  describe "[dump formats]" do
+    it "dumps hex" do
+      assert_output(Regexp.compile(Regexp.escape("52 75 62 79 20 1F32B"))){
+        unicopy("52 75 62 79 20 1F32B", print: true, dump: "hex")
+      }
+    end
+
+    it "dumps hex (string input)" do
+      assert_output(Regexp.compile(Regexp.escape("52 75 62 79 20 1F32B"))){
+        unicopy("Ruby 🌫", print: true, string: true, dump: "hex")
+      }
+    end
+
+    it "dumps uplus (string input) [default]" do
+      assert_output(Regexp.compile(Regexp.escape("U+0052 U+0075 U+0062 U+0079 U+0020 U+1F32B"))){
+        unicopy("Ruby 🌫", print: true, string: true)
+      }
+    end
+
+    it "dumps 0x (string input)" do
+      assert_output(Regexp.compile(Regexp.escape("0x0052 0x0075 0x0062 0x0079 0x0020 0x1F32B"))){
+        unicopy("Ruby 🌫", print: true, string: true, dump: "0x")
+      }
+    end
+
+    it "dumps dec (string input)" do
+      assert_output(Regexp.compile(Regexp.escape("82 117 98 121 32 127787"))){
+        unicopy("Ruby 🌫", print: true, string: true, dump: "dec")
+      }
+    end
+
+    it "dumps ruby (string input)" do
+      assert_output(Regexp.compile(Regexp.escape("\\u{52 75 62 79 20 1F32B}"))){
+        unicopy("Ruby 🌫", print: true, string: true, dump: "ruby")
+      }
+    end
+
+    it "dumps js (string input)" do
+      assert_output(Regexp.compile(Regexp.escape("\\u0052\\u0075\\u0062\\u0079\\u0020\\uD83C\\uDF2B"))){
+        unicopy("Ruby 🌫", print: true, string: true, dump: "js")
+      }
+    end
+
+    it "dumps es6 (string input)" do
+      assert_output(Regexp.compile(Regexp.escape("\\u{52}\\u{75}\\u{62}\\u{79}\\u{20}\\u{1F32B}"))){
+        unicopy("Ruby 🌫", print: true, string: true, dump: "es6")
+      }
+    end
+
+    it "dumps css (string input)" do
+      assert_output(Regexp.compile(Regexp.escape("\\52\\75\\62\\79\\20\\1f32b"))){
+        unicopy("Ruby 🌫", print: true, string: true, dump: "css")
+      }
+    end
+
+    it "dumps html-hex (string input)" do
+      assert_output(Regexp.compile(Regexp.escape("Ruby 🌫"))){
+        unicopy("Ruby 🌫", print: true, string: true, dump: "html-hex")
+      }
+    end
+
+    it "dumps html-dec (string input)" do
+      assert_output(Regexp.compile(Regexp.escape("Ruby 🌫"))){
+        unicopy("Ruby 🌫", print: true, string: true, dump: "html-dec")
+      }
+    end
+
+    it "dumps bytes-utf8 (string input)" do
+      assert_output(Regexp.compile(Regexp.escape("52 75 62 79 20 F0 9F 8C AB"))){
+        unicopy("Ruby 🌫", print: true, string: true, dump: "bytes-utf8")
+      }
+    end
+  end
+end

data/unicopy.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+
+require File.dirname(__FILE__) + "/lib/unicopy/version"
+
+Gem::Specification.new do |gem|
+  gem.name          = "unicopy"
+  gem.version       = Unicopy::VERSION
+  gem.summary       = "Converts Unicode codepoints to a string (or vice versa) and copies it to the system clipboard."
+  gem.description   = "Converts Unicode codepoints to a string (or vice versa) and copies it to the system clipboard. Can also convert codepoints to many dump formats."
+  gem.authors       = ["Jan Lelis"]
+  gem.email         = ["mail@janlelis.de"]
+  gem.homepage      = "https://github.com/janlelis/unicopy"
+  gem.license       = "MIT"
+
+  gem.files         = Dir["{**/}{.*,*}"].select{ |path| File.file?(path) && path !~ /^(pkg|screenshots)/ }
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency 'paint', '>= 0.9', '< 3.0'
+  gem.add_dependency 'rationalist', '~> 2.0'
+  gem.add_dependency 'clipboard', '~> 1.1'
+
+  gem.required_ruby_version = "~> 2.0"
+end

metadata

@@ -0,0 +1,111 @@
+--- !ruby/object:Gem::Specification
+name: unicopy
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Jan Lelis
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-04-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: paint
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.9'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.9'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rationalist
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: clipboard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+description: Converts Unicode codepoints to a string (or vice versa) and copies it
+  to the system clipboard. Can also convert codepoints to many dump formats.
+email:
+- mail@janlelis.de
+executables:
+- unicopy
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- Gemfile
+- Gemfile.lock
+- MIT-LICENSE.txt
+- README.md
+- Rakefile
+- bin/unicopy
+- lib/unicopy.rb
+- lib/unicopy/kernel_method.rb
+- lib/unicopy/version.rb
+- spec/unicopy_spec.rb
+- unicopy.gemspec
+homepage: https://github.com/janlelis/unicopy
+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.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.8
+signing_key: 
+specification_version: 4
+summary: Converts Unicode codepoints to a string (or vice versa) and copies it to
+  the system clipboard.
+test_files:
+- spec/unicopy_spec.rb