hexdump 0.3.0 → 1.0.0

data/lib/hexdump/theme/ansi.rb

@@ -0,0 +1,81 @@
+module Hexdump
+  class Theme
+    #
+    # Represents an ANSI control sequence.
+    #
+    # @api private
+    #
+    # @since 1.0.0
+    #
+    class ANSI
+      # ANSI reset control sequence
+      RESET = "\e[0m"
+
+      PARAMETERS = {
+        reset:     RESET,
+
+        bold:      "\e[1m",
+        faint:     "\e[2m",
+        italic:    "\e[3m",
+        underline: "\e[4m",
+        invert:    "\e[7m",
+        strike:    "\e[9m",
+        black:     "\e[30m",
+        red:       "\e[31m",
+        green:     "\e[32m",
+        yellow:    "\e[33m",
+        blue:      "\e[34m",
+        magenta:   "\e[35m",
+        cyan:      "\e[36m",
+        white:     "\e[37m",
+
+        on_black:   "\e[40m",
+        on_red:     "\e[41m",
+        on_green:   "\e[42m",
+        on_yellow:  "\e[43m",
+        on_blue:    "\e[44m",
+        on_magenta: "\e[45m",
+        on_cyan:    "\e[46m",
+        on_white:   "\e[47m"
+      }
+
+      # The style name(s).
+      #
+      # @return [Symbol, Array<Symbol>] style
+      attr_reader :parameters
+
+      # The ANSI string.
+      #
+      # @return [String]
+      attr_reader :string
+
+      #
+      # Initializes an ANSI control sequence.
+      #
+      # @param [Symbol, Array<Symbol>] style
+      #
+      def initialize(parameters)
+        @parameters = parameters
+
+        @string = String.new
+
+        Array(parameters).each do |name|
+          @string << PARAMETERS.fetch(name) do
+            raise(ArgumentError,"unknown ANSI parameter: #{name}")
+          end
+        end
+      end
+
+      #
+      # Returns the ANSI string.
+      #
+      # @return [String]
+      #
+      def to_s
+        @string
+      end
+
+      alias to_str to_s
+    end
+  end
+end

data/lib/hexdump/theme/rule.rb

@@ -0,0 +1,159 @@
+require 'hexdump/theme/ansi'
+
+require 'strscan'
+
+module Hexdump
+  class Theme
+    #
+    # Represents a color highlighting rule.
+    #
+    # @api private
+    #
+    # @since 1.0.0
+    #
+    class Rule
+
+      # The default style to apply to strings.
+      #
+      # @return [ANSI, nil]
+      attr_reader :style
+
+      # Highlighting rules for exact strings.
+      #
+      # @return [Hash{String => ANSI}]
+      attr_reader :highlight_strings
+
+      # Highlighting rules for matching substrings.
+      #
+      # @return [Hash{String => ANSI}]
+      attr_reader :highlight_regexps
+
+      #
+      # Initializes the color.
+      #
+      # @param [Symbol, Array<Symbol>] style
+      #   The default style name(s). See {ANSI::PARAMETERS}.
+      #
+      # @param [Hash{String,Regexp => Symbol,Array<Symbol>}, nil] highlights
+      #   Optional highlighting rules.
+      #
+      def initialize(style: nil, highlights: nil)
+        @reset = ANSI::RESET
+        
+        @style = if style
+                   ANSI.new(style)
+                 end
+
+        @highlight_strings = {}
+        @highlight_regexps = {}
+
+        if highlights
+          highlights.each do |pattern,style|
+            highlight(pattern,style)
+          end
+        end
+      end
+
+      #
+      # The highlighting rules.
+      #
+      # @return [Hash{String,Regexp => ANSI}]
+      #   The combination of {#highlight_strings} and {#highlight_regexps}.
+      #
+      def highlights
+        @highlight_strings.merge(@highlight_regexps)
+      end
+
+      #
+      # Adds a highlighting rule.
+      # 
+      # @param [String, Regexp] pattern
+      #   The exact String to highlight or regular expression to highlight.
+      #
+      # @param [Symbol, Array<Symbol>] style
+      #   The style name(s). See {ANSI::PARAMETERS}.
+      #
+      # @raise [ArgumentError]
+      #   The given pattern was not a String or Regexp.
+      #
+      # @example
+      #   hexdump.style.numeric.highlight('00', :faint)
+      #
+      # @example
+      #   hexdump.style.index.highlight(/00$/, [:white, :bold])
+      #
+      # @api public
+      #
+      def highlight(pattern,style)
+        ansi = ANSI.new(style)
+
+        case pattern
+        when String
+          @highlight_strings[pattern] = ansi
+        when Regexp
+          @highlight_regexps[pattern] = ansi
+        else
+          raise(ArgumentError,"pattern must be a String or Regexp: #{pattern.inspect}")
+        end
+      end
+
+      #
+      # Applies coloring/highlighting to a string.
+      #
+      # @param [String] string
+      #   The string to color/highlight.
+      #
+      # @return [String]
+      #   The colored the string.
+      #
+      def apply(string)
+        if (!@highlight_strings.empty? || !@highlight_regexps.empty?)
+          apply_highlight(string)
+        elsif @style
+          "#{@style}#{string}#{@reset}"
+        else
+          string
+        end
+      end
+
+      private
+
+      def apply_highlight(string)
+        if (ansi = @highlight_strings[string])
+          # highlight the whole string
+          "#{ansi}#{string}#{@reset}"
+        else
+          scanner    = StringScanner.new(string)
+          new_string = String.new
+
+          until scanner.eos?
+            matched = false
+
+            @highlight_regexps.each do |regexp,ansi|
+              if (match = scanner.scan(regexp))
+                # highlight the match
+                new_string << "#{ansi}#{match}#{@reset}"
+                new_string << "#{@style}" unless scanner.eos?
+                matched = true
+                break
+              end
+            end
+
+            unless matched
+              # next char
+              new_string << scanner.getch
+            end
+          end
+
+          if @style
+            new_string.prepend(@style) unless new_string.start_with?("\e")
+            new_string << @reset       unless new_string.end_with?(@reset)
+          end
+
+          new_string
+        end
+      end
+
+    end
+  end
+end

data/lib/hexdump/theme.rb

@@ -0,0 +1,61 @@
+require 'hexdump/theme/rule'
+
+module Hexdump
+  #
+  # Represents a hexdump theme (styling + highlighting).
+  #
+  # @api semipublic
+  #
+  # @since 1.0.0
+  #
+  class Theme
+
+    # The index styling/highlights.
+    #
+    # @return [Rule, nil]
+    #
+    # @api public
+    attr_reader :index
+
+    # The numeric styling/highlights.
+    #
+    # @return [Rule, nil]
+    #
+    # @api public
+    attr_reader :numeric
+
+    # The chars styling/highlights.
+    #
+    # @return [Rule, nil]
+    #
+    # @api public
+    attr_reader :chars
+
+    #
+    # Initializes the theme.
+    #
+    # @param [Hash{:index,:numeric,:chars => Symbol,Array<Symbol>,nil}] style
+    #   The default style of the index, numeric, and/or chars columns.
+    #
+    # @param [Hash{:index,:numeric,:chars => Hash{String,Regexp => Symbol,Array<Symbol>},nil}] highlights
+    #   The highlighting rules for the index, numeric, and/or chars columns.
+    #
+    def initialize(style: {}, highlights: {})
+      @index   = Rule.new(
+                   style:      style[:index],
+                   highlights: highlights[:index]
+                 )
+
+      @numeric = Rule.new(
+                   style:      style[:numeric],
+                   highlights: highlights[:numeric]
+                 )
+
+      @chars   = Rule.new(
+                   style:      style[:chars],
+                   highlights: highlights[:chars]
+                )
+    end
+
+  end
+end

data/lib/hexdump/type.rb

@@ -0,0 +1,232 @@
+module Hexdump
+  #
+  # @api private
+  #
+  # @since 1.0.0
+  #
+  class Type
+
+    # The endian-ness of the type.
+    #
+    # @return [:little, :big, nil]
+    attr_reader :endian
+
+    # The size in bytes of the type.
+    #
+    # @return [1, 2, 4, 8]
+    attr_reader :size
+
+    #
+    # Initializes the type.
+    #
+    # @param [Symbol] name
+    #
+    # @param [:little, :big, nil] endian
+    #
+    # @param [1, 2, 4, 8] size
+    #
+    # @param [Boolean] signed
+    #
+    # @raise [ArgumentError]
+    #   Invalid `endian:` or `size:` values.
+    #
+    def initialize(size: , endian: nil, signed: )
+      @endian = endian
+      @size   = size
+      @signed = signed
+    end
+
+    # 
+    # Whether the type is signed.
+    #
+    # @return [Boolean]
+    #
+    def signed?
+      @signed
+    end
+
+    # 
+    # Whether the type is unsigned.
+    #
+    # @return [Boolean]
+    #
+    def unsigned?
+      !@signed
+    end
+
+    # The native endian-ness.
+    NATIVE_ENDIAN = if [0x1].pack('I') == [0x1].pack('N')
+                      :big
+                    else
+                      :little
+                    end
+
+    #
+    # Represents a signed integer type.
+    #
+    class Int < self
+
+      #
+      # Initializes the int type.
+      #
+      # @param [:little, :big] endian (NATIVE_ENDIAN)
+      #   The endian-ness of the int type.
+      #
+      def initialize(endian: NATIVE_ENDIAN, **kwargs)
+        super(signed: true, endian: endian, **kwargs)
+      end
+
+    end
+
+    class Int8 < Int
+
+      #
+      # @see Int#initialize
+      #
+      def initialize(**kwargs)
+        super(size: 1, endian: nil, **kwargs)
+      end
+
+    end
+
+    class Int16 < Int
+
+      #
+      # @see Int#initialize
+      #
+      def initialize(**kwargs)
+        super(size: 2, **kwargs)
+      end
+
+    end
+
+    class Int32 < Int
+
+      #
+      # @see Int#initialize
+      #
+      def initialize(**kwargs)
+        super(size: 4, **kwargs)
+      end
+
+    end
+
+    class Int64 < Int
+
+      #
+      # @see Int#initialize
+      #
+      def initialize(**kwargs)
+        super(size: 8, **kwargs)
+      end
+
+    end
+
+    #
+    # Represents a unsigned integer type.
+    #
+    class UInt < self
+
+      #
+      # Initializes the uint type.
+      #
+      # @param [:little, :big] endian (NATIVE_ENDIAN)
+      #   The endian-ness of the uint type.
+      #
+      def initialize(endian: NATIVE_ENDIAN, **kwargs)
+        super(signed: false, endian: endian, **kwargs)
+      end
+
+    end
+
+    class UInt8 < UInt
+
+      #
+      # @see UInt#initialize
+      #
+      def initialize(**kwargs)
+        super(size: 1, endian: nil, **kwargs)
+      end
+
+    end
+
+    class UInt16 < UInt
+
+      #
+      # @see UInt#initialize
+      #
+      def initialize(**kwargs)
+        super(size: 2, **kwargs)
+      end
+
+    end
+
+    class UInt32 < UInt
+
+      #
+      # @see UInt#initialize
+      #
+      def initialize(**kwargs)
+        super(size: 4, **kwargs)
+      end
+
+    end
+
+    class UInt64 < UInt
+
+      #
+      # @see UInt#initialize
+      #
+      def initialize(**kwargs)
+        super(size: 8, **kwargs)
+      end
+
+    end
+
+    #
+    # Represents a single-byte character.
+    #
+    class Char < Int8
+    end
+
+    #
+    # Represents a single-byte unsigned character.
+    #
+    class UChar < UInt8
+    end
+
+    #
+    # Represents a floating point type.
+    #
+    class Float < self
+
+      #
+      # Initializes the float type.
+      #
+      # @param [:little, :big] endian (NATIVE_ENDIAN)
+      #   The endian-ness of the float type.
+      #
+      def initialize(endian: NATIVE_ENDIAN, **kwargs)
+        super(signed: true, endian: endian, **kwargs)
+      end
+
+    end
+
+    class Float32 < Float
+
+      def initialize(**kwargs)
+        super(size: 4, **kwargs)
+      end
+
+    end
+
+    class Float64 < Float
+
+      def initialize(**kwargs)
+        super(size: 8, **kwargs)
+      end
+
+    end
+
+  end
+end