hexdump 0.3.0 → 1.0.1

data/spec/spec_helper.rb

@@ -1 +1,3 @@
 require 'rspec'
+require 'simplecov'
+SimpleCov.start

data/spec/theme/ansi_spec.rb

@@ -0,0 +1,242 @@
+require 'spec_helper'
+require 'hexdump/theme/ansi'
+
+describe Hexdump::Theme::ANSI do
+  describe "RESET" do
+    subject { described_class::RESET }
+
+    it "must equal '\\e[0m'" do
+      expect(subject).to eq("\e[0m")
+    end
+  end
+
+  describe "PARAMETERS" do
+    subject { described_class::PARAMETERS }
+
+    describe ":reset" do
+      subject { super()[:reset] }
+
+      it "must equal '\\e[0m'" do
+        expect(subject).to eq("\e[0m")
+      end
+    end
+
+    describe ":bold" do
+      subject { super()[:bold] }
+
+      it "must equal '\\e[1m'" do
+        expect(subject).to eq("\e[1m")
+      end
+    end
+
+    describe ":faint" do
+      subject { super()[:faint] }
+
+      it "must equal '\\e[2m'" do
+        expect(subject).to eq("\e[2m")
+      end
+    end
+
+    describe ":italic" do
+      subject { super()[:italic] }
+
+      it "must equal '\\e[3m'" do
+        expect(subject).to eq("\e[3m")
+      end
+    end
+
+    describe ":underline" do
+      subject { super()[:underline] }
+
+      it "must equal '\\e[4m'" do
+        expect(subject).to eq("\e[4m")
+      end
+    end
+
+    describe ":invert" do
+      subject { super()[:invert] }
+
+      it "must equal '\\e[7m'" do
+        expect(subject).to eq("\e[7m")
+      end
+    end
+
+    describe ":strike" do
+      subject { super()[:strike] }
+
+      it "must equal '\\e[9m'" do
+        expect(subject).to eq("\e[9m")
+      end
+    end
+
+    describe ":black" do
+      subject { super()[:black] }
+
+      it "must equal '\\e[30m'" do
+        expect(subject).to eq("\e[30m")
+      end
+    end
+
+    describe ":red" do
+      subject { super()[:red] }
+
+      it "must equal '\\e[31m'" do
+        expect(subject).to eq("\e[31m")
+      end
+    end
+
+    describe ":green" do
+      subject { super()[:green] }
+
+      it "must equal '\\e[32m'" do
+        expect(subject).to eq("\e[32m")
+      end
+    end
+
+    describe ":yellow" do
+      subject { super()[:yellow] }
+
+      it "must equal '\\e[33m'" do
+        expect(subject).to eq("\e[33m")
+      end
+    end
+
+    describe ":blue" do
+      subject { super()[:blue] }
+
+      it "must equal '\\e[34m'" do
+        expect(subject).to eq("\e[34m")
+      end
+    end
+
+    describe ":magenta" do
+      subject { super()[:magenta] }
+
+      it "must equal '\\e[35m'" do
+        expect(subject).to eq("\e[35m")
+      end
+    end
+
+    describe ":cyan" do
+      subject { super()[:cyan] }
+
+      it "must equal '\\e[36m'" do
+        expect(subject).to eq("\e[36m")
+      end
+    end
+
+    describe ":white" do
+      subject { super()[:white] }
+
+      it "must equal '\\e[37m'" do
+        expect(subject).to eq("\e[37m")
+      end
+    end
+
+    describe ":on_black" do
+      subject { super()[:on_black] }
+
+      it "must equal '\\e[40m'" do
+        expect(subject).to eq("\e[40m")
+      end
+    end
+
+    describe ":on_red" do
+      subject { super()[:on_red] }
+
+      it "must equal '\\e[41m'" do
+        expect(subject).to eq("\e[41m")
+      end
+    end
+
+    describe ":on_green" do
+      subject { super()[:on_green] }
+
+      it "must equal '\\e[42m'" do
+        expect(subject).to eq("\e[42m")
+      end
+    end
+
+    describe ":on_yellow" do
+      subject { super()[:on_yellow] }
+
+      it "must equal '\\e[43m'" do
+        expect(subject).to eq("\e[43m")
+      end
+    end
+
+    describe ":on_blue" do
+      subject { super()[:on_blue] }
+
+      it "must equal '\\e[44m'" do
+        expect(subject).to eq("\e[44m")
+      end
+    end
+
+    describe ":on_magenta" do
+      subject { super()[:on_magenta] }
+
+      it "must equal '\\e[45m'" do
+        expect(subject).to eq("\e[45m")
+      end
+    end
+
+    describe ":on_cyan" do
+      subject { super()[:on_cyan] }
+
+      it "must equal '\\e[46m'" do
+        expect(subject).to eq("\e[46m")
+      end
+    end
+
+    describe ":on_white" do
+      subject { super()[:on_white] }
+
+      it "must equal '\\e[47m'" do
+        expect(subject).to eq("\e[47m")
+      end
+    end
+  end
+
+  describe "#initialize" do
+    context "when given one parameters name" do
+      let(:parameters) { :bold }
+
+      subject { described_class.new(parameters) }
+
+      it "must set #parameters to that parameters name" do
+        expect(subject.parameters).to eq(parameters)
+      end
+
+      it "must set #ansi to that parameters's ANSI string" do
+        expect(subject.string).to eq(described_class::PARAMETERS[:bold])
+      end
+    end
+
+    context "when given multiple parameters names" do
+      let(:parameters) { [:bold, :green] }
+
+      subject { described_class.new(parameters) }
+
+      it "must set #parameters to that parameters names" do
+        expect(subject.parameters).to eq(parameters)
+      end
+
+      it "must set #ansi to the combined parameters's ANSI strings" do
+        expect(subject.string).to eq(
+          described_class::PARAMETERS[:bold] + described_class::PARAMETERS[:green]
+        )
+      end
+    end
+
+    context "when given an unknown parameters name" do
+      let(:parameter) { :foo }
+
+      it do
+        expect {
+          described_class.new(parameter)
+        }.to raise_error(ArgumentError,"unknown ANSI parameter: #{parameter}")
+      end
+    end
+  end
+end

data/spec/theme/rule_spec.rb

@@ -0,0 +1,199 @@
+require 'spec_helper'
+require 'hexdump/theme/rule'
+
+describe Hexdump::Theme::Rule do
+  describe "#initialize" do
+    context "when no style is given" do
+      subject { described_class.new }
+
+      it "must set #style to nil" do
+        expect(subject.style).to be(nil)
+      end
+    end
+
+    context "when given a style" do
+      let(:style) { :bold }
+
+      subject { described_class.new(style: style) }
+
+      it "must initialize #style based on the given style" do
+        expect(subject.style).to            be_kind_of(Hexdump::Theme::ANSI)
+        expect(subject.style.parameters).to eq(style)
+      end
+    end
+
+    context "when given no highlights: keyword argument" do
+      it "must initialize #highlight_strings to {}" do
+        expect(subject.highlight_strings).to eq({})
+      end
+
+      it "must initialize #highlight_regexps to {}" do
+        expect(subject.highlight_regexps).to eq({})
+      end
+    end
+
+    context "when given the highlights: keyword argument" do
+      let(:highlights) { {/[a-f]/ => :green, '00' => :red} }
+
+      subject { described_class.new(highlights: highlights) }
+
+      it "must populate #highlight_strings with the String keys" do
+        expect(subject.highlight_strings['00']).to be_kind_of(Hexdump::Theme::ANSI)
+        expect(subject.highlight_strings['00'].parameters).to eq(:red)
+      end
+
+      it "must populate #highlight_regexps with the Regexp keys" do
+        expect(subject.highlight_regexps[/[a-f]/]).to be_kind_of(Hexdump::Theme::ANSI)
+        expect(subject.highlight_regexps[/[a-f]/].parameters).to eq(:green)
+      end
+    end
+  end
+
+  describe "#highlights" do
+    let(:highlights) { {/[a-f]/ => :green, '00' => :red} }
+
+    subject { described_class.new(highlights: highlights) }
+
+    it "must combine #highlight_strings and #highlight_regexps" do
+      expect(subject.highlights).to eq(subject.highlight_strings.merge(subject.highlight_regexps))
+    end
+  end
+
+  describe "#highlight" do
+    context "when given a String pattern" do
+      let(:pattern) { '00' }
+      let(:style)   { :red }
+
+      before { subject.highlight(pattern,style) }
+
+      it "must populate #highlight_strings with the given String" do
+        expect(subject.highlight_strings[pattern]).to be_kind_of(Hexdump::Theme::ANSI)
+        expect(subject.highlight_strings[pattern].parameters).to eq(style)
+      end
+    end
+
+    context "when given a Regexp pattern" do
+      let(:pattern) { /[a-f]/ }
+      let(:style)   { :green }
+
+      before { subject.highlight(pattern,style) }
+
+      it "must populate #highlight_regexps with the given Regexp" do
+        expect(subject.highlight_regexps[pattern]).to be_kind_of(Hexdump::Theme::ANSI)
+        expect(subject.highlight_regexps[pattern].parameters).to eq(style)
+      end
+    end
+
+    context "when not given a String or Regexp" do
+      let(:pattern) { Object.new }
+      let(:style)   { :red }
+
+      it do
+        expect {
+          subject.highlight(pattern,style)
+        }.to raise_error(ArgumentError,"pattern must be a String or Regexp: #{pattern.inspect}")
+      end
+    end
+  end
+
+  describe "#apply" do
+    let(:string) { "00f0" }
+
+    let(:highlights) { {'00' => :faint, /[a-f]/ => :green} }
+
+    let(:reset) { Hexdump::Theme::ANSI::RESET              }
+    let(:red)   { Hexdump::Theme::ANSI::PARAMETERS[:red]   }
+    let(:green) { Hexdump::Theme::ANSI::PARAMETERS[:green] }
+
+    context "when there are #highlight_strings rules" do
+      let(:highlights) { {"00" => :red} }
+
+      subject { described_class.new(highlights: highlights) }
+
+      context "and the whole string matches a #highlight_strings rule" do
+        let(:string) { '00' }
+
+        it "must highlight the whole string" do
+          expect(subject.apply(string)).to eq("#{red}#{string}#{reset}")
+        end
+      end
+
+      context "but the string does not match any of the rules" do
+        let(:string) { 'ff' }
+
+        it "must return the given String" do
+          expect(subject.apply(string)).to eq(string)
+        end
+      end
+    end
+
+    context "when there are #highlight_regexps rules" do
+      let(:highlights) { {/f/ => :green} }
+
+      subject { described_class.new(highlights: highlights) }
+
+      context "and the whole string matches a #highlight_strings rule" do
+        let(:string) { '00f0' }
+
+        it "must highlight the matching substrings within the string" do
+          expect(subject.apply(string)).to eq("00#{green}f#{reset}0")
+        end
+
+        context "and #style is initialized" do
+          subject do
+            described_class.new(
+              style:      :cyan,
+              highlights: highlights
+            )
+          end
+
+          it "must re-enable the default style after resetting the highlighting" do
+            expect(subject.apply(string)).to include("#{green}f#{reset}#{subject.style}")
+          end
+
+          context "when the beginning of the string is not highlighted" do
+            let(:string) { "0f" }
+
+            it "must prepend the string with the default style" do
+              expect(subject.apply(string)).to eq("#{subject.style}0#{green}f#{reset}")
+            end
+          end
+
+          context "when the end of the string is not highlighted" do
+            let(:string) { "f0" }
+
+            it "must append ANSI reset to the end of the string" do
+              expect(subject.apply(string)).to eq("#{green}f#{reset}#{subject.style}0#{reset}")
+            end
+          end
+        end
+      end
+
+      context "but the string does not match any of the rules" do
+        let(:string) { '0000' }
+
+        it "must return the given String" do
+          expect(subject.apply(string)).to eq(string)
+        end
+      end
+    end
+
+    context "when #style is initialized" do
+      let(:style) { :cyan }
+
+      subject { described_class.new(style: style) }
+
+      it "must wrap the given string with the style's ANSI string and reset" do
+        expect(subject.apply(string)).to eq("#{subject.style}#{string}#{reset}")
+      end
+    end
+
+    context "when #style is not initialized" do
+      let(:string) { 'ff' }
+
+      it "must return the given String" do
+        expect(subject.apply(string)).to eq(string)
+      end
+    end
+  end
+end

data/spec/theme_spec.rb

@@ -0,0 +1,94 @@
+require 'spec_helper'
+require 'hexdump/theme'
+
+describe Hexdump::Theme do
+  describe "#initialize" do
+    it "must initialize #index" do
+      expect(subject.index).to be_kind_of(Hexdump::Theme::Rule)
+    end
+
+    it "must initialize #numeric" do
+      expect(subject.numeric).to be_kind_of(Hexdump::Theme::Rule)
+    end
+
+    it "must initialize #chars" do
+      expect(subject.chars).to be_kind_of(Hexdump::Theme::Rule)
+    end
+
+    context "when given a style Hash" do
+      let(:index_style)   { :white }
+      let(:numeric_style) { :cyan  }
+      let(:chars_style)   { :blue  }
+
+      subject do
+        described_class.new(
+          style: {
+            index:   index_style,
+            numeric: numeric_style,
+            chars:   chars_style
+          }
+        )
+      end
+
+      it "must initialize #index" do
+        expect(subject.index).to be_kind_of(Hexdump::Theme::Rule)
+      end
+
+      it "must initialize #index.style" do
+        expect(subject.index.style.parameters).to eq(index_style)
+      end
+
+      it "must initialize #numeric" do
+        expect(subject.numeric).to be_kind_of(Hexdump::Theme::Rule)
+      end
+
+      it "must initialize #numeric.style" do
+        expect(subject.numeric.style.parameters).to eq(numeric_style)
+      end
+
+      it "must initialize #chars" do
+        expect(subject.chars).to be_kind_of(Hexdump::Theme::Rule)
+      end
+
+      it "must initialize #chars.style" do
+        expect(subject.chars.style.parameters).to eq(chars_style)
+      end
+    end
+
+    context "when given a highlight Hash" do
+      let(:index_pattern)      { /00$/ }
+      let(:index_highlight)    { :white }
+      let(:index_highlights)   { {index_pattern => index_highlight} }
+
+      let(:numeric_pattern)    { '00'    }
+      let(:numeric_highlight)  { :faint  }
+      let(:numeric_highlights) { {numeric_pattern => numeric_highlight}  }
+
+      let(:chars_pattern)    { /A-Z/  }
+      let(:chars_highlight)  { :bold  }
+      let(:chars_highlights) { {chars_pattern => chars_highlight}  }
+
+      subject do
+        described_class.new(
+          highlights: {
+            index:   index_highlights,
+            numeric: numeric_highlights,
+            chars:   chars_highlights
+          }
+        )
+      end
+
+      it "must initialize #index.highlights" do
+        expect(subject.index.highlights[index_pattern].parameters).to eq(index_highlight)
+      end
+
+      it "must initialize #numeric.highlights" do
+        expect(subject.numeric.highlights[numeric_pattern].parameters).to eq(numeric_highlight)
+      end
+
+      it "must initialize #chars.highlights" do
+        expect(subject.chars.highlights[chars_pattern].parameters).to eq(chars_highlight)
+      end
+    end
+  end
+end