gdcm 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 854120bce512df7e3a80fb22685e825f45f06a92598bbafe5d99aa19faca89ad
+  data.tar.gz: 916dce2f8f78d51513972d186aa392fd192b0d8f7a995ca77bb57d6d2e4dee94
+SHA512:
+  metadata.gz: 6514e8369d16786dddb8056f16e5ec6d14aacdf8ae7c54f4027006feace229d1bf9ba2eba3726f46be1ab70bc548c09daaa7e587face7404b4cc4bbc7076ada7
+  data.tar.gz: e343afd083dde1ad00d03e1d082694293293b7ffac4aef77e9c2ff5a33d82fe425448b7e107ff41bcc1e3c44c6ae50ef15bfdd50b3aec3c189c8f04411d7875f

data/LICENSE

@@ -0,0 +1,18 @@
+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,170 @@
+# GDCM
+
+A ruby wrapper for [GDCM tools](http://gdcm.sourceforge.net/)
+
+## Information
+
+Inspired by MiniMagick ruby gem, this realization was created based on same DSL structure (but for GDCM tools).
+
+## Requirements
+
+GDCM command-line tool has to be installed. You can
+check if you have it installed by running
+
+```sh
+$ gdcminfo --version
+gdcminfo: gdcm 3.0.10
+```
+
+## Installation
+
+Add the gem to your Gemfile:
+
+```rb
+gem "gdcm"
+```
+
+## Usage
+
+Let's first see a basic example.
+
+```rb
+require "gdcm"
+
+package = GDCM::Package.open("original.dcm")
+
+package.convert do |convert|
+  convert.raw
+  convert.verbose
+end
+
+package.path
+package.write "output.dcm"
+```
+
+`GDCM::Package.open` makes a copy of the package, and further methods modify
+that copy (the original stays untouched). The writing part is necessary because
+the copy is just temporary, it gets garbage collected when we lose reference
+to the package.
+
+
+On the other hand, if we want the original package to actually *get* modified,
+we can use `GDCM::Package.new`.
+
+```rb
+package = GDCM::Package.new("original.dcm")
+package.path
+
+package.convert do |convert|
+  convert.raw
+  convert.verbose
+end
+# Not calling #write, because it's not a copy
+```
+
+### Attributes
+
+
+To get the all information about the package, GDCM gives you a handy method
+which returns the output from `gdcminfo` in hash format:
+
+```rb
+package.info.data #=>
+#{"MediaStorage"=>"1.2.840.10008.5.1.4.1.1.77.1.5.1",                             
+# "TransferSyntax"=>"1.2.840.10008.1.2.4.70",                                     
+# "NumberOfDimensions"=>"2",                                                      
+# "Dimensions"=>"(4000,4000,1)",                                                  
+# "SamplesPerPixel"=>"3",                                                         
+# "BitsAllocated"=>"8",                                                           
+# "BitsStored"=>"8",                                                              
+# "HighBit"=>"7",                                                                 
+# "PixelRepresentation"=>"0",                                                     
+# "ScalarType found"=>"UINT8",                                                    
+# "PhotometricInterpretation"=>"RGB",                                             
+# "PlanarConfiguration"=>"0",                                                     
+# "Origin"=>"(0,0,0)",                                                            
+# "Spacing"=>"(1,1,1)",
+# "DirectionCosines"=>"(1,0,0,0,1,0)",
+# "Rescale Intercept/Slope"=>"(0,1)",
+# "Orientation Label"=>"AXIAL"}
+```
+
+
+### Configuration
+
+```rb
+GDCM.configure do |config|
+  config.timeout = 5
+end
+```
+
+### Package validation
+
+By default, GDCM validates package each time it's opening them. It
+validates them by running `gdcminfo` on them, and see if GDCM tools finds
+them valid. This adds slight overhead to the whole processing. Sometimes it's
+safe to assume that all input and output packages are valid by default and turn
+off validation:
+
+```rb
+GDCM.configure do |config|
+  config.validate_on_create = false
+end
+```
+
+You can test whether an package is valid:
+
+```rb
+package.valid?
+package.validate! # raises GDCM::Invalid if package is invalid
+```
+
+### Logging
+
+You can choose to log GDCM commands and their execution times:
+
+```rb
+GDCM.logger.level = Logger::DEBUG
+```
+```
+D, [2022-04-11T12:07:39.240238 #59063] DEBUG -- : [0.11s] gdcminfo /var/folders/4d/k113_9r544nfj8k0bfxtjx0m0000gn/T/gdcm20220411-59063-8yvk5s.dcm
+```
+
+In Rails you'll probably want to set `GDCM.logger = Rails.logger`.
+
+### Metal
+
+If you want to be close to the metal, you can use GDCM's command-line
+tools directly.
+
+```rb
+GDCM::Tool::Convert.new do |convert|
+  convert.raw
+  convert.verbose
+  convert << "input.dcm"
+  convert << "output.dcm"
+end #=> `gdcmconv --raw --verbose input.dcm output.dcm`
+
+# OR
+
+convert = GDCM::Tool::Convert.new
+convert.raw
+convert.verbose
+convert << "input.jpg"
+convert << "output.jpg"
+convert.call #=> `gdcmconv --raw --verbose input.dcm output.dcm`
+```
+
+## Troubleshooting
+
+### Errors being raised when they shouldn't
+
+
+If you're using the tool directly, you can pass `whiny: false` value to the
+constructor:
+
+```rb
+GDCM::Tool::Identify.new(whiny: false) do |b|
+  b.help
+end
+```

data/Rakefile

@@ -0,0 +1,4 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+$:.unshift 'lib'

data/lib/gdcm/configuration.rb

@@ -0,0 +1,75 @@
+require 'gdcm/utilities'
+require 'logger'
+
+module GDCM
+  module Configuration
+    ##
+    # If you don't want commands to take too long, you can set a timeout (in
+    # seconds).
+    #
+    # @return [Integer]
+    #
+    attr_accessor :timeout
+    ##
+    # When get to `true`, it outputs each command to STDOUT in their shell
+    # version.
+    #
+    # @return [Boolean]
+    #
+    attr_reader :debug
+    ##
+    # Logger for {#debug}, default is `GDCM::Logger.new(STDOUT)`, but
+    # you can override it, for example if you want the logs to be written to
+    # a file.
+    #
+    # @return [Logger]
+    #
+    attr_accessor :logger
+
+    ##
+    # If set to `true`, it will `identify` every newly created image, and raise
+    # `MiniMagick::Invalid` if the image is not valid. Useful for validating
+    # user input, although it adds a bit of overhead. Defaults to `true`.
+    #
+    # @return [Boolean]
+    #
+    attr_accessor :validate_on_create
+    ##
+    # If set to `true`, it will `identify` every image that gets written (with
+    # {GDCM::Image#write}), and raise `GDCM::Invalid` if the image
+    # is not valid. Useful for validating that processing was sucessful,
+    # although it adds a bit of overhead. Defaults to `true`.
+    #
+    # @return [Boolean]
+
+    #
+    attr_accessor :whiny
+
+    ##
+    # Instructs GDCM how to execute the shell commands. Available
+    # APIs are "open3" (default) and "posix-spawn" (requires the "posix-spawn"
+    # gem).
+    #
+    # @return [String]
+    #
+    attr_accessor :shell_api
+
+    def self.extended(base)
+      base.validate_on_create = true
+      base.whiny = true
+      base.shell_api = "open3"
+      base.logger = Logger.new($stdout).tap { |l| l.level = Logger::INFO }
+    end
+
+    ##
+    # @yield [self]
+    # @example
+    #   GDCM.configure do |config|
+    #     config.timeout = 5
+    #   end
+    #
+    def configure
+      yield self
+    end
+  end
+end

data/lib/gdcm/package/info.rb

@@ -0,0 +1,43 @@
+module GDCM
+  class Package
+    class Info
+      attr_reader :package_instance
+
+      def initialize package_instance
+        @package_instance = package_instance
+      end
+
+      def data
+        if meta.respond_to?(:lines)
+          meta.lines.each_with_object({}) do |line, memo|
+            case line
+            when /^MediaStorage is (?<media_storage>[\d.]+)/
+              memo['MediaStorage'] = $~[:media_storage]
+            when /^TransferSyntax is (?<transfer_syntax>[\d.]+)/
+              memo['TransferSyntax'] = $~[:transfer_syntax]
+            else
+              key, _, value = line.partition(/:[\s]*/).map(&:strip)
+
+              memo[key] = value
+            end
+          end
+        end
+      end
+
+      def meta
+        @meta ||= identify
+      end
+
+      def clear
+        @meta = nil
+      end
+
+      def identify
+        GDCM::Tool::Identify.new do |builder|
+          yield builder if block_given?
+          builder << package_instance.path
+        end
+      end
+    end
+  end
+end

data/lib/gdcm/package.rb

@@ -0,0 +1,174 @@
+require 'tempfile'
+require 'stringio'
+require 'pathname'
+
+require 'gdcm/package/info'
+require 'gdcm/utilities'
+
+module GDCM
+  class Package
+
+    ##
+    # This is the primary loading method used by all of the other class
+    # methods.
+    #
+    # Use this to pass in a stream object. Must respond to #read(size) or be a
+    # binary string object (BLOB)
+    #
+    # @param stream [#read, String] Some kind of stream object that needs
+    #   to be read or is a binary String blob
+    # @param ext [String] A manual extension to use for reading the file. Not
+    #   required, but if you are having issues, give this a try.
+    # @return [GDCM::Image]
+    #
+    def self.read(stream, ext = nil)
+      if stream.is_a?(String)
+        stream = StringIO.new(stream)
+      end
+
+      create(ext) { |file| IO.copy_stream(stream, file) }
+    end
+
+    ##
+    # Opens a specific file either on the local file system.
+    # Use this if you don't want to overwrite file.
+    #
+    # Extension is either guessed from the path or you can specify it as a
+    # second parameter.
+    #
+    # @param path [String] Either a local file path
+    # @param ext [String] Specify the extension you want to read it as
+    # @param options [Hash] Specify options for the open method
+    # @return [GDCM::Image] The loaded file
+    #
+    def self.open(path, ext = nil, options = {})
+      options, ext = ext, nil if ext.is_a?(Hash)
+
+      # Don't use Kernel#open, but reuse its logic
+      openable =
+        if path.respond_to?(:open)
+          path
+        else
+          options = { binmode: true }.merge(options)
+          Pathname(path)
+        end
+
+      ext ||= File.extname(openable.to_s)
+      ext.sub!(/:.*/, '') # hack for filenames that include a colon
+
+      openable.open(**options) { |file| read(file, ext) }
+    end
+
+    ##
+    # Used to create a new file object data-copy.
+    #
+    # Takes an extension in a block and can be used to build a new file
+    # object. Used by both {.open} and {.read} to create a new object. Ensures
+    # we have a good tempfile.
+    #
+    # @param ext [String] Specify the extension you want to read it as
+    # @param validate [Boolean] If false, skips validation of the created
+    #   file. Defaults to true.
+    # @yield [Tempfile] You can #write bits to this object to create the new
+    #   file
+    # @return [GDCM::Image] The created file
+    #
+    def self.create(ext = nil, validate = GDCM.validate_on_create, &block)
+      tempfile = GDCM::Utilities.tempfile(ext.to_s.downcase, &block)
+
+      new(tempfile.path, tempfile).tap do |file|
+        file.validate! if validate
+      end
+    end
+
+    attr_reader :path
+    attr_reader :tempfile
+    attr_reader :meta
+
+    def initialize(input_path, tempfile = nil)
+      @path = input_path.to_s
+      @tempfile = tempfile
+    end
+
+    def info
+      @info ||= GDCM::Package::Info.new(self)
+    end
+
+    def to_blob
+      File.binread(path)
+    end
+
+    def valid?
+      validate!
+      true
+    rescue GDCM::Invalid
+      false
+    end
+
+    def validate!
+      identify
+    rescue GDCM::Error => error
+      raise GDCM::Invalid, error.message
+    end
+
+    def identify
+      info.identify
+    end
+
+    def convert
+      if @tempfile
+        new_tempfile = GDCM::Utilities.tempfile(".dcm")
+        new_path = new_tempfile.path
+      else
+        new_path = Pathname(path).sub_ext(".dcm").to_s
+      end
+
+      input_path = path.dup
+
+      GDCM::Tool::Convert.new do |convert|
+        yield convert if block_given?
+        convert << input_path
+        convert << new_path
+      end
+
+      if @tempfile
+        destroy!
+        @tempfile = new_tempfile
+      else
+        File.delete(path) unless path == new_path
+      end
+
+      path.replace new_path
+      info.clear
+
+      self
+    end
+
+    ##
+    # Writes the temporary file out to either a file location (by passing in a
+    # String) or by passing in a Stream that you can #write(chunk) to
+    # repeatedly
+    #
+    # @param output_to [String, Pathname, #read] Some kind of stream object
+    #   that needs to be read or a file path as a String
+    #
+    def write(output_to)
+      case output_to
+      when String, Pathname
+        FileUtils.copy_file path, output_to unless path == output_to.to_s
+      else
+        IO.copy_stream File.open(path, "rb"), output_to
+      end
+    end
+
+    ##
+    # Destroys the tempfile (created by {.open}) if it exists.
+    #
+    def destroy!
+      if @tempfile
+        FileUtils.rm_f @tempfile.path.sub(/mpc$/, "cache") if @tempfile.path.end_with?(".mpc")
+        @tempfile.unlink
+      end
+    end
+  end
+end

data/lib/gdcm/shell.rb

@@ -0,0 +1,78 @@
+require "timeout"
+require "benchmark"
+
+module GDCM
+  ##
+  # Sends commands to the shell (more precisely, it sends commands directly to
+  # the operating system).
+  #
+  # @private
+  #
+  class Shell
+
+    def run(command, options = {})
+      stdout, stderr, status = execute(command, stdin: options[:stdin])
+
+      if status != 0 && options.fetch(:whiny, GDCM.whiny)
+        fail GDCM::Error, "`#{command.join(" ")}` failed with error:\n#{stderr}"
+      end
+
+      $stderr.print(stderr) unless options[:stderr] == false
+
+      [stdout, stderr, status]
+    end
+
+    def execute(command, options = {})
+      stdout, stderr, status =
+        log(command.join(" ")) do
+          send("execute_#{GDCM.shell_api.gsub("-", "_")}", command, options)
+        end
+
+      [stdout, stderr, status.exitstatus]
+    rescue Errno::ENOENT, IOError
+      ["", "executable not found: \"#{command.first}\"", 127]
+    end
+
+    private
+
+    def execute_open3(command, options = {})
+      require "open3"
+
+      # We would ideally use Open3.capture3, but it wouldn't allow us to
+      # terminate the command after timing out.
+      Open3.popen3(*command) do |in_w, out_r, err_r, thread|
+        [in_w, out_r, err_r].each(&:binmode)
+        stdout_reader = Thread.new { out_r.read }
+        stderr_reader = Thread.new { err_r.read }
+        begin
+          in_w.write options[:stdin].to_s
+        rescue Errno::EPIPE
+        end
+        in_w.close
+
+        unless thread.join(GDCM.timeout)
+          Process.kill("TERM", thread.pid) rescue nil
+          Process.waitpid(thread.pid)      rescue nil
+          raise Timeout::Error, "GDCM command timed out: #{command}"
+        end
+
+        [stdout_reader.value, stderr_reader.value, thread.value]
+      end
+    end
+
+    def execute_posix_spawn(command, options = {})
+      require "posix-spawn"
+      child = POSIX::Spawn::Child.new(*command, input: options[:stdin].to_s, timeout: GDCM.timeout)
+      [child.out, child.err, child.status]
+    rescue POSIX::Spawn::TimeoutExceeded
+      raise Timeout::Error, "GDCM command timed out: #{command}"
+    end
+
+    def log(command, &block)
+      value = nil
+      duration = Benchmark.realtime { value = block.call }
+      GDCM.logger.debug "[%.2fs] %s" % [duration, command]
+      value
+    end
+  end
+end

data/lib/gdcm/tool/convert.rb

@@ -0,0 +1,9 @@
+module GDCM
+  class Tool
+    class Convert < GDCM::Tool
+      def initialize(*args)
+        super("gdcmconv", *args)
+      end
+    end
+  end
+end

data/lib/gdcm/tool/identify.rb

@@ -0,0 +1,9 @@
+module GDCM
+  class Tool
+    class Identify < GDCM::Tool
+      def initialize(*args)
+        super("gdcminfo", *args)
+      end
+    end
+  end
+end

data/lib/gdcm/tool.rb

@@ -0,0 +1,217 @@
+require "gdcm/shell"
+
+module GDCM
+  ##
+  # Abstract class that wraps command-line tools. It shouldn't be used directly,
+  # but through one of its subclasses. Use
+  # this class if you want to be closer to the metal and execute GDCM
+  # commands directly, but still with a nice Ruby interface.
+  #
+  class Tool
+    ##
+    # Aside from classic instantiation, it also accepts a block, and then
+    # executes the command in the end.
+    #
+    # @example
+    #   version = GDCM::Tool::Identify.new { |b| b.version }
+    #   puts version
+    #
+    # @return [GDCM::Tool, String] If no block is given, returns an
+    #   instance of the tool, if block is given, returns the output of the
+    #   command.
+    #
+    def self.new(*args)
+      instance = super(*args)
+
+      if block_given?
+        yield instance
+        instance.call
+      else
+        instance
+      end
+    end
+
+    # @private
+    attr_reader :name, :args
+
+    # @param name [String]
+    # @param options [Hash]
+    # @option options [Boolean] :whiny Whether to raise errors on non-zero
+    #   exit codes.
+    # @example
+    #   GDCM::Tool::Identify.new(whiny: false) do |identify|
+    #     identify.help # returns exit status 1, which would otherwise throw an error
+    #   end
+    def initialize(name, options = {})
+      @name  = name
+      @args  = []
+      @whiny = options.is_a?(Hash) ? options.fetch(:whiny, GDCM.whiny) : options
+    end
+
+    ##
+    # Executes the command that has been built up.
+    #
+    # @example
+    #   convert = GDCM::Tool::Convert.new
+    #   convert.resize("500x500")
+    #   convert << "path/to/file.dcm"
+    #   convert.call # executes `convert --resize 500x500 path/to/file.dcm`
+    #
+    # @example
+    #   convert = GDCM::Tool::Convert.new
+    #   # build the command
+    #   convert.call do |stdout, stderr, status|
+    #     # ...
+    #   end
+    #
+    # @yield [Array] Optionally yields stdout, stderr, and exit status
+    #
+    # @return [String] Returns the output of the command
+    #
+    def call(*args)
+      options = args[-1].is_a?(Hash) ? args.pop : {}
+      whiny = args.fetch(0, @whiny)
+
+      options[:whiny] = whiny
+      options[:stderr] = false if block_given?
+
+      shell = GDCM::Shell.new
+      stdout, stderr, status = shell.run(command, options)
+      yield stdout, stderr, status if block_given?
+
+      stdout.chomp("\n")
+    end
+
+    ##
+    # The currently built-up command.
+    #
+    # @return [Array<String>]
+    #
+    # @example
+    #   convert = GDCM::Tool::Convert.new
+    #   convert.resize "500x500"
+    #   convert.contrast
+    #   convert.command #=> ["convert", "--resize", "500x500", "--contrast"]
+    #
+    def command
+      [*executable, *args]
+    end
+
+    def executable
+      exe = [name]
+      exe
+    end
+
+    ##
+    # Appends raw options, useful for appending file paths.
+    #
+    # @return [self]
+    #
+    def <<(arg)
+      args << arg.to_s
+      self
+    end
+
+    ##
+    # Merges a list of raw options.
+    #
+    # @return [self]
+    #
+    def merge!(new_args)
+      new_args.each { |arg| self << arg }
+      self
+    end
+
+    ##
+    # Changes the last operator to its "plus" form.
+    #
+    # @example
+    #   GDCM::Tool::Convert.new do |convert|
+    #     convert.antialias.+
+    #     convert.distort.+("Perspective", "0,0,4,5 89,0,45,46")
+    #   end
+    #   # executes `convert +antialias +distort Perspective '0,0,4,5 89,0,45,46'`
+    #
+    # @return [self]
+    #
+    def +(*values)
+      args[-1] = args[-1].sub(/^-/, '+')
+      self.merge!(values)
+      self
+    end
+
+    ##
+    # Create an GDCM stack in the command (surround.
+    #
+    # @example
+    #   GDCM::Tool::Convert.new do |convert|
+    #     convert << "1.dcm"
+    #     convert.stack do |stack|
+    #       stack << "2.dcm"
+    #       stack.rotate(30)
+    #     end
+    #     convert.append.+
+    #     convert << "3.dcm"
+    #   end
+    #   # executes `convert 1.dcm \( 2.dcm --rotate 30 \) +append 3.dcm`
+    #
+    def stack(*args)
+      self << "("
+      args.each do |value|
+        case value
+        when Hash   then value.each { |key, value| send(key, *value) }
+        when String then self << value
+        end
+      end
+      yield self if block_given?
+      self << ")"
+    end
+
+    ##
+    # Adds GDCM's pseudo-filename `-` for standard input.
+    #
+    # @example
+    #   identify = GDCM::Tool::Identify.new
+    #   identify.stdin
+    #   identify.call(stdin: content)
+    #   # executes `identify -` with the given standard input
+    #
+    def stdin
+      self << "-"
+    end
+
+    ##
+    # Adds GDCM's pseudo-filename `-` for standard output.
+    #
+    # @example
+    #   content = GDCM::Tool::Convert.new do |convert|
+    #     convert << "1.dcm"
+    #     convert.auto_orient
+    #     convert.stdout
+    #   end
+    #   # executes `convert 1.dcm --auto-orient -` which returns file contents
+    #
+    def stdout
+      self << "-"
+    end
+
+    ##
+    # Any undefined method will be transformed into a CLI option
+    #
+    # @example
+    #   convert = GDCM::Tool.new("convert")
+    #   convert.adaptive_blur("...")
+    #   convert.foo_bar
+    #   convert.command.join(" ") # => "convert --adaptive-blur ... --foo-bar"
+    #
+    def method_missing(name, *args)
+      option = "--#{name.to_s.tr('_', '-')}"
+      self << option
+      self.merge!(args)
+      self
+    end
+  end
+end
+
+require "gdcm/tool/convert"
+require "gdcm/tool/identify"

data/lib/gdcm/utilities.rb

@@ -0,0 +1,35 @@
+require "tempfile"
+
+module GDCM
+  # @private
+  module Utilities
+
+    module_function
+
+    ##
+    # Cross-platform way of finding an executable in the $PATH.
+    #
+    # @example
+    #   GDCM::Utilities.which('ruby') #=> "/usr/bin/ruby"
+    #
+    def which(cmd)
+      exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
+      ENV.fetch('PATH').split(File::PATH_SEPARATOR).each do |path|
+        exts.each do |ext|
+          exe = File.join(path, "#{cmd}#{ext}")
+          return exe if File.executable? exe
+        end
+      end
+      nil
+    end
+
+    def tempfile(extension)
+      Tempfile.new(["gdcm", extension]).tap do |tempfile|
+        tempfile.binmode
+        yield tempfile if block_given?
+        tempfile.close
+      end
+    end
+
+  end
+end

data/lib/gdcm/version.rb

@@ -0,0 +1,17 @@
+module GDCM
+  ##
+  # @return [Gem::Version]
+  #
+  def self.version
+    Gem::Version.new VERSION::STRING
+  end
+
+  module VERSION
+    MAJOR = 1
+    MINOR = 0
+    TINY  = 0
+    PRE   = nil
+
+    STRING = [MAJOR, MINOR, TINY, PRE].compact.join('.')
+  end
+end

data/lib/gdcm.rb

@@ -0,0 +1,22 @@
+require 'gdcm/version'
+require 'gdcm/configuration'
+
+module GDCM
+  extend GDCM::Configuration
+
+  ##
+  # Returns GDCM's version.
+  #
+  # @return [String]
+  def self.cli_version
+    output = GDCM::Tool::Identify.new(&:version)
+    output[/\d+\.\d+\.\d+(-\d+)?/]
+  end
+
+  class Error < RuntimeError; end
+  class Invalid < StandardError; end
+
+end
+
+require 'gdcm/tool'
+require 'gdcm/package'

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification
+name: gdcm
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- sanzstez
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2022-04-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  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'
+- !ruby/object:Gem::Dependency
+  name: posix-spawn
+  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'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  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'
+description: Ruby adapter for GDCM tools for DICOM medical files.
+email:
+- sanzstez@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- Rakefile
+- lib/gdcm.rb
+- lib/gdcm/configuration.rb
+- lib/gdcm/package.rb
+- lib/gdcm/package/info.rb
+- lib/gdcm/shell.rb
+- lib/gdcm/tool.rb
+- lib/gdcm/tool/convert.rb
+- lib/gdcm/tool/identify.rb
+- lib/gdcm/utilities.rb
+- lib/gdcm/version.rb
+homepage: https://github.com/sanzstez/gdcm
+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:
+- You must have GDCM tools installed
+rubygems_version: 3.0.9
+signing_key:
+specification_version: 4
+summary: Ruby adapter for GDCM tools for DICOM medical files.
+test_files: []