zhexdump 0.0.1

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+tmp.rb

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in zhexdump.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Andrey "Zed" Zaikin
+
+MIT License
+
+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,122 @@
+# ZHexdump
+
+A highly flexible hexdump implementation.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'zhexdump'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install zhexdump
+
+## Usage
+
+### Simple dump (to STDOUT)
+```ruby
+  ZHexdump.dump "abc123"*5
+
+  # output:
+  00000000: 61 62 63 31 32 33 61 62  63 31 32 33 61 62 63 31  |abc123abc123abc1|
+  00000010: 32 33 61 62 63 31 32 33  61 62 63 31 32 33        |23abc123abc123  |
+```
+
+### Dump to string
+```ruby
+  s = ''
+  ZHexdump.dump "abc123", :output => s
+  puts "START\n#{s}END"
+
+  # output:
+  START
+  00000000: 61 62 63 31 32 33                                 |abc123          |
+  END
+```
+
+### Custom width
+```ruby
+  ZHexdump.dump "abc123"*2, :width => 3
+
+  # output:
+  00000000: 61 62 63  |abc|
+  00000003: 31 32 33  |123|
+  00000006: 61 62 63  |abc|
+  00000009: 31 32 33  |123|
+```
+
+### Dumping only part of data
+```ruby
+  ZHexdump.dump "0123456789abcdef", :size => 5, :offset => 3
+
+  # output:
+  00000003: 33 34 35 36 37                                    |34567           |
+```
+
+### Hide offset
+```ruby
+  ZHexdump.dump "abc123", :offset => false
+
+  # output:
+  61 62 63 31 32 33                                 |abc123          |
+```
+
+### Add to offset
+```ruby
+  ZHexdump.dump "abc123", :add => 0x1234
+
+  # output:
+  00001234: 61 62 63 31 32 33                                 |abc123          |
+```
+
+### Duplicate rows hiding enabled (default)
+```ruby
+  ZHexdump.dump "0123456789abcdef"*5
+
+  # output:
+  00000000: 30 31 32 33 34 35 36 37  38 39 61 62 63 64 65 66  |0123456789abcdef|
+  *
+  00000050: 
+```
+
+### Duplicate rows hiding disabled
+```ruby
+  ZHexdump.dump "0123456789abcdef"*5, :dedup => false
+
+  # output:
+  00000000: 30 31 32 33 34 35 36 37  38 39 61 62 63 64 65 66  |0123456789abcdef|
+  00000010: 30 31 32 33 34 35 36 37  38 39 61 62 63 64 65 66  |0123456789abcdef|
+  00000020: 30 31 32 33 34 35 36 37  38 39 61 62 63 64 65 66  |0123456789abcdef|
+  00000030: 30 31 32 33 34 35 36 37  38 39 61 62 63 64 65 66  |0123456789abcdef|
+  00000040: 30 31 32 33 34 35 36 37  38 39 61 62 63 64 65 66  |0123456789abcdef|
+```
+
+### Tail comment
+```ruby
+  ZHexdump.dump "abc123", :tail => " comment here"
+
+  # output:
+  00000000: 61 62 63 31 32 33                                 |abc123          | comment here
+```
+
+### Row preprocessing
+```ruby
+  lineno = 1
+  ZHexdump.dump "abc123"*10 do |row, pos, ascii|
+    row.gsub!(/ 3[123]/, " ..")
+    row.insert 0, "  (line ##{lineno})  "
+    ascii.tr! '123',"_"
+    lineno += 1
+  end
+
+  # output:
+    (line #1)  00000000: 61 62 63 .. .. .. 61 62  63 .. .. .. 61 62 63 ..  |abc___abc___abc_|
+    (line #2)  00000010: .. .. 61 62 63 .. .. ..  61 62 63 .. .. .. 61 62  |__abc___abc___ab|
+    (line #3)  00000020: 63 .. .. .. 61 62 63 ..  .. .. 61 62 63 .. .. ..  |c___abc___abc___|
+    (line #4)  00000030: 61 62 63 .. .. .. 61 62  63 .. .. ..              |abc___abc___    |
+```

data/README.md.tpl

@@ -0,0 +1,77 @@
+# ZHexdump
+
+A very flexible hexdump implementation.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'zhexdump'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install zhexdump
+
+## Usage
+
+### Simple dump (to STDOUT)
+```ruby
+  ZHexdump.dump "abc123"*5
+```
+
+### Dump to string
+```ruby
+  s = ''
+  ZHexdump.dump "abc123", :output => s
+  puts "START\n#{s}END"
+```
+
+### Custom width
+```ruby
+  ZHexdump.dump "abc123"*2, :width => 3
+```
+
+### Dumping only part of data
+```ruby
+  ZHexdump.dump "0123456789abcdef", :size => 5, :offset => 3
+```
+
+### Hide offset
+```ruby
+  ZHexdump.dump "abc123", :offset => false
+```
+
+### Add to offset
+```ruby
+  ZHexdump.dump "abc123", :add => 0x1234
+```
+
+### Duplicate rows hiding enabled (default)
+```ruby
+  ZHexdump.dump "0123456789abcdef"*5
+```
+
+### Duplicate rows hiding disabled
+```ruby
+  ZHexdump.dump "0123456789abcdef"*5, :dedup => false
+```
+
+### Tail comment
+```ruby
+  ZHexdump.dump "abc123", :tail => " comment here"
+```
+
+### Row preprocessing
+```ruby
+  lineno = 1
+  ZHexdump.dump "abc123"*10 do |row, pos, ascii|
+    row.gsub!(/ 3[123]/, " ..")
+    row.insert 0, "  (line ##{lineno})  "
+    ascii.tr! '123',"_"
+    lineno += 1
+  end
+```

data/Rakefile

@@ -0,0 +1,32 @@
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+desc "run specs"
+RSpec::Core::RakeTask.new
+
+task :default => :spec
+
+desc "build readme"
+task :readme do
+  tpl = File.read('README.md.tpl')
+  result = tpl.gsub(/^### ([^~`\n]+?)\n```ruby(.+?)^```/m) do |x|
+    title, code = $1, $2
+    
+    File.open("tmp.rb", "w:utf-8") do |f|
+#      f.puts "#coding: utf-8"
+#      f.puts "$:.unshift('../lib')"
+      f.puts "require 'zhexdump'"
+#      f.puts "srand 0"
+      f.puts code
+    end
+
+    puts "[.] #{title} .. "
+    out = `ruby -Ilib tmp.rb`
+    exit unless $?.success?
+
+    x.sub code, code+"\n  # output:\n"+out.split("\n").map{|x| "  #{x}"}.join("\n")+"\n"
+  end
+  File.unlink("tmp.rb")
+  File.open('README.md','w'){ |f| f << result }
+  #puts result
+end

data/lib/zhexdump.rb

@@ -0,0 +1,113 @@
+#!/usr/bin/env ruby
+require File.expand_path("zhexdump/version", File.dirname(__FILE__))
+
+module ZHexdump
+
+  # two methods for using when module ZHexdump is included in some class,
+  # f.ex. String:
+
+  # default hexdump to STDOUT (unless options[:output] overridden)
+  def hexdump options = {}, &block
+    ZHexdump.dump self, options, &block
+  end
+
+  # default hexdump to string (unless options[:output] overridden)
+  def to_hexdump options = {}, &block
+    r = ''
+    options[:output] ||= r
+    ZHexdump.dump self, options, &block
+    r
+  end
+
+  class << self
+    def dump data, h = {}
+      offset      = h.fetch(:offset, 0)
+      dedup       = h.fetch(:dedup, true)
+      show_offset = h.fetch(:show_offset, h.fetch(:show_addr, true))
+
+      if offset == false
+        show_offset = false
+        offset = 0
+      end
+
+      add         = h[:add]    || 0
+      size        = h[:size]   || (data.size-offset)
+      tail        = h[:tail]   || "\n"
+      width       = h[:width]  || 0x10                 # row width, in bytes
+      output      = h[:output] || $>
+
+      size = data.size-offset if size+offset > data.size
+
+      prevhex = ''; c = nil; prevdup = false; start = offset
+      while true
+        ascii = ''; hex = ''
+        width.times do |i|
+          hex << ' ' if i%8==0 && i>0
+          if c = ((size > 0) && data[offset+i])
+            hex << "%02x " % c.ord
+            ascii << ((32..126).include?(c.ord) ? c : '.')
+          else
+            hex << '   '
+            ascii << ' '
+          end
+          size-=1
+        end
+
+        if dedup && hex == prevhex
+          row = "*"
+          yield(row, offset+add, ascii) if block_given?
+          unless prevdup
+            output << "\n" if offset > start
+            output << row
+          end
+          prevdup = true
+        else
+          row = (show_offset ?  ("%08x: " % (offset + add)) : '') + hex
+          yield(row, offset+add, ascii) if block_given?
+          row << ' |' + ascii + "|"
+          output << "\n" if offset > start
+          output << row
+          prevdup = false
+        end
+
+        offset += width
+        prevhex = hex
+        break if size <= 0
+      end
+      if show_offset && prevdup
+        row = "%08x: " % (offset + add)
+        yield(row) if block_given?
+        output << "\n" << row
+      end
+      output << tail
+    end # dump
+
+    alias :hexdump :dump
+  end # class << self
+end # module ZHexdump
+
+Zhexdump = ZHexdump
+
+if $0 == __FILE__
+  h = {}
+  case ARGV.size
+    when 0
+      puts "gimme fname [offset] [size]"
+      exit
+    when 1
+      fname = ARGV[0]
+    when 2
+      fname = ARGV[0]
+      h[:offset] = ARGV[1].to_i
+    when 3
+      fname = ARGV[0]
+      h[:offset] = ARGV[1].to_i
+      h[:size]   = ARGV[2].to_i
+  end
+  File.open(fname,"rb") do |f|
+    f.seek h[:offset] if h[:offset]
+    @data = f.read(h[:size])
+  end
+  puts ZHexdump.dump(@data)
+end
+

data/lib/zhexdump/version.rb

@@ -0,0 +1,3 @@
+module ZHexdump
+  VERSION = "0.0.1"
+end

data/spec/hexdump_spec.rb

@@ -0,0 +1,142 @@
+require 'spec_helper'
+require 'stringio'
+
+describe ZHexdump do
+  it "dumps to string" do
+    s = ''
+    ZHexdump.dump "foo", :output => s
+    s.should == "00000000: 66 6f 6f                                          |foo             |\n"
+  end
+
+  it "dumps to stdout" do
+    io = StringIO.new
+    begin
+      saved_stdout, $> = $>, io
+      ZHexdump.dump "foo"
+    ensure
+      $> = saved_stdout
+    end
+
+    io.rewind
+    io.read.should == "00000000: 66 6f 6f                                          |foo             |\n"
+  end
+
+  it "dumps w/o addr if show_addr=false" do
+    s = ''
+    ZHexdump.dump "foo", :output => s, :show_addr => false
+    s.should == "66 6f 6f                                          |foo             |\n"
+  end
+
+  it "dumps w/o addr if show_offset=false" do
+    s = ''
+    ZHexdump.dump "foo", :output => s, :show_offset => false
+    s.should == "66 6f 6f                                          |foo             |\n"
+  end
+
+  it "dumps w/o addr if offset=false" do
+    s = ''
+    ZHexdump.dump "foo", :output => s, :offset => false
+    s.should == "66 6f 6f                                          |foo             |\n"
+  end
+
+  it "respects :size" do
+    data = 'foo'*100
+    s = ''
+    ZHexdump.dump data, :output => s, :size => 3
+    s.should == "00000000: 66 6f 6f                                          |foo             |\n"
+  end
+
+  it "respects :offset" do
+    data = 'foobar'*100
+    s = ''
+    ZHexdump.dump data, :output => s, :offset => 2, :size => 3
+    s.should == "00000002: 6f 62 61                                          |oba             |\n"
+  end
+
+  it "adds :add to offset shown" do
+    data = 'foo'*100
+    s = ''
+    ZHexdump.dump data, :output => s, :size => 3, :add => 0x1234
+    s.should == "00001234: 66 6f 6f                                          |foo             |\n"
+  end
+
+  it "shows tail" do
+    data = 'foo'
+    s = ''
+    ZHexdump.dump data, :output => s, :tail => 'tail'
+    s.should == "00000000: 66 6f 6f                                          |foo             |tail"
+  end
+
+  it "shows tail only on last line" do
+    data = 'foo'*6
+    s = ''
+    ZHexdump.dump data, :output => s, :tail => 'tail'
+    s.should == <<-EOF.split("\n").map(&:strip).join("\n")
+      00000000: 66 6f 6f 66 6f 6f 66 6f  6f 66 6f 6f 66 6f 6f 66  |foofoofoofoofoof|
+      00000010: 6f 6f                                             |oo              |tail
+    EOF
+  end
+
+  it "no dedup: should have exactly 0x10 lines" do
+    s = ''
+    ZHexdump.dump "x"*0x100, :output => s, :dedup => false
+    s.count("\n").should == 0x10
+  end
+
+  it "default dedup: should have exactly 2 lines" do
+    s = ''
+    ZHexdump.dump "x"*0x100, :output => s
+    s.count("\n").should == 3
+    s.strip.should == <<-EOF.split("\n").map(&:strip).join("\n")
+      00000000: 78 78 78 78 78 78 78 78  78 78 78 78 78 78 78 78  |xxxxxxxxxxxxxxxx|
+      *
+      00000100:
+    EOF
+  end
+
+  it "column width=4, no offset, each row prepend" do
+    data = "ABCDEFGHIJKLMNOPQRST"
+    s = ''
+    ZHexdump.dump(data, :output => s, :width => 4, :show_offset => false) do |row, offset|
+      row.insert(0,"color %4s:  " % "##{(offset/4)}")
+    end
+    s.should == <<-EOF.split("\n").map(&:strip).join("\n") + "\n"
+      color   #0:  41 42 43 44  |ABCD|
+      color   #1:  45 46 47 48  |EFGH|
+      color   #2:  49 4a 4b 4c  |IJKL|
+      color   #3:  4d 4e 4f 50  |MNOP|
+      color   #4:  51 52 53 54  |QRST|
+    EOF
+  end
+
+  it "column width=3, no offset, each row prepend" do
+    data = "ABCDEFGHI"
+    s = ''
+    ZHexdump.dump(data, :output => s, :width => 3, :show_offset => false) do |row, offset|
+      row.insert(0,"color %4s:  " % "##{(offset/3)}")
+    end
+    s.should == <<-EOF.split("\n").map(&:strip).join("\n") + "\n"
+      color   #0:  41 42 43  |ABC|
+      color   #1:  44 45 46  |DEF|
+      color   #2:  47 48 49  |GHI|
+    EOF
+  end
+
+  it "prepends spaces before offset" do
+    data = 'foo'
+    s = ''
+    ZHexdump.dump(data, :output => s) do |x|
+      x.insert(0,"  ")
+    end
+    s.should == "  00000000: 66 6f 6f                                          |foo             |\n"
+  end
+
+  it "modifies ascii" do
+    data = 'foo'
+    s = ''
+    ZHexdump.dump(data, :output => s) do |row, offset, ascii|
+      ascii.sub! 'foo', 'xxx'
+    end
+    s.should == "00000000: 66 6f 6f                                          |xxx             |\n"
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,14 @@
+require File.join(File.dirname(__FILE__), '../lib/zhexdump.rb')
+
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  #config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  #config.order = 'random'
+end

data/zhexdump.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'zhexdump/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "zhexdump"
+  gem.version       = ZHexdump::VERSION
+  gem.authors       = ["Andrey \"Zed\" Zaikin"]
+  gem.email         = ["zed.0xff@gmail.com"]
+  gem.summary       = %q{A highly flexible hexdump implementation.}
+  gem.description   = gem.summary
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($/)
+  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_development_dependency 'rspec'
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification
+name: zhexdump
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Andrey "Zed" Zaikin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-03-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A highly flexible hexdump implementation.
+email:
+- zed.0xff@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- LICENSE.txt
+- README.md
+- README.md.tpl
+- Rakefile
+- lib/zhexdump.rb
+- lib/zhexdump/version.rb
+- spec/hexdump_spec.rb
+- spec/spec_helper.rb
+- zhexdump.gemspec
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: A highly flexible hexdump implementation.
+test_files:
+- spec/hexdump_spec.rb
+- spec/spec_helper.rb