hex 0.1.0

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,14 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "rspec", "~> 2.6.0"
+  gem "yard", "~> 0.7.1"
+  gem "bundler", "~> 1.0.13"
+  gem "jeweler", "~> 1.6.0"
+  gem "rcov", ">= 0"
+end

data/Gemfile.lock

@@ -0,0 +1,30 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.2)
+    git (1.2.5)
+    jeweler (1.6.0)
+      bundler (~> 1.0.0)
+      git (>= 1.2.5)
+      rake
+    rake (0.9.0)
+    rcov (0.9.9)
+    rspec (2.6.0)
+      rspec-core (~> 2.6.0)
+      rspec-expectations (~> 2.6.0)
+      rspec-mocks (~> 2.6.0)
+    rspec-core (2.6.1)
+    rspec-expectations (2.6.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.6.0)
+    yard (0.7.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.0.13)
+  jeweler (~> 1.6.0)
+  rcov
+  rspec (~> 2.6.0)
+  yard (~> 0.7.1)

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Frédéric Mascaro
+
+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.rdoc

@@ -0,0 +1,42 @@
+= hex
+
+== INTEL Hex file
+
+Read and write Intel HEX file.
+
+See [[http://en.wikipedia.org/wiki/Intel_hex]].
+
+== HEX conversion
+
+HexUtil convert to HEX 8, 16 or 32
+
+	> WOoo::Util::HexUtil.to_hex8(11)
+	"0B"
+
+	> WOoo::Util::HexUtil.to_hex8("11")
+	"0B"
+
+	> WOoo::Util::HexUtil.to_hex8([11, 16, 255])
+	["0B", "10", "FF"]
+
+	> WOoo::Util::HexUtil.to_i("0B")
+	11
+
+	> WOoo::Util::HexUtil.to_i(["0B", "10", "FF"])
+	[11, 16, 255]
+
+== Contributing to hex
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2011 Frédéric Mascaro. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,42 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "hex"
+  gem.homepage = "http://github.com/rfred999/hex"
+  gem.license = "MIT"
+  gem.summary = %Q{Convert hex data to/from integer, and read/write Intel HEX File.}
+  gem.description = %Q{Convert hex data to/from integer, and read/write Intel HEX File.}
+  gem.email = "frederic.mascaro@wo-oo.com"
+  gem.authors = ["Frédéric Mascaro"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :default => :spec
+
+require 'yard'
+YARD::Rake::YardocTask.new

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/hex.gemspec

@@ -0,0 +1,68 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{hex}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Frédéric Mascaro"]
+  s.date = %q{2011-05-22}
+  s.description = %q{Convert hex data to/from integer, and read/write Intel HEX File.}
+  s.email = %q{frederic.mascaro@wo-oo.com}
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+    ".rspec",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "README.rdoc",
+    "Rakefile",
+    "VERSION",
+    "hex.gemspec",
+    "lib/wo_oo/electronics/intel_hex_file.rb",
+    "lib/wo_oo/electronics/intel_hex_grammar.rb",
+    "lib/wo_oo/electronics/intel_hex_grammar.treetop",
+    "lib/wo_oo/util/hex.rb",
+    "spec/hex_util_spec.rb",
+    "spec/intel_hex_file_spec.rb",
+    "spec/resources/wikipedia_sample.hex",
+    "spec/spec_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/rfred999/hex}
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.6.2}
+  s.summary = %q{Convert hex data to/from integer, and read/write Intel HEX File.}
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<rspec>, ["~> 2.6.0"])
+      s.add_development_dependency(%q<yard>, ["~> 0.7.1"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.0.13"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.6.0"])
+      s.add_development_dependency(%q<rcov>, [">= 0"])
+    else
+      s.add_dependency(%q<rspec>, ["~> 2.6.0"])
+      s.add_dependency(%q<yard>, ["~> 0.7.1"])
+      s.add_dependency(%q<bundler>, ["~> 1.0.13"])
+      s.add_dependency(%q<jeweler>, ["~> 1.6.0"])
+      s.add_dependency(%q<rcov>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<rspec>, ["~> 2.6.0"])
+    s.add_dependency(%q<yard>, ["~> 0.7.1"])
+    s.add_dependency(%q<bundler>, ["~> 1.0.13"])
+    s.add_dependency(%q<jeweler>, ["~> 1.6.0"])
+    s.add_dependency(%q<rcov>, [">= 0"])
+  end
+end
+

data/lib/wo_oo/electronics/intel_hex_file.rb

@@ -0,0 +1,69 @@
+require "wo_oo/electronics/intel_hex_grammar"
+require "wo_oo/util/hex"
+require "pp"
+
+module WOoo
+  module Electronics
+    class IntelHexFile
+      def self.read(path)
+        file_content = File.read(path)
+        
+        parser = WOoo::Electronics::IntelHexParser.new
+        result = parser.parse(file_content)
+        
+        unless result.nil?
+          hex_data = result.eval
+          
+          WOoo::Util::HexUtil.to_i(hex_data.scan(/../))
+        else
+          # TO FIX
+          puts "PARSING ERROR!"
+          puts parser.terminal_failures.join("\n")
+          puts "----"
+        end
+      end
+      
+      # ----------------------------------------------------------------
+      
+      def self.write(path, data, start_address = 0)
+        next_address = start_address
+
+        File.open(path, "w") do |file|
+          while (line_data = data.slice!(0..16)).size > 0
+            line_size = line_data.size
+            
+            file.print ":"
+            
+            line = WOoo::Util::HexUtil.to_hex8(line_size)
+            line += WOoo::Util::HexUtil.to_hex16(next_address)
+            line += "00"
+            line += WOoo::Util::HexUtil.to_hex8(line_data).join("")
+                        
+            file.print line
+            file.print WOoo::Util::HexUtil.to_hex8(checksum(line))
+            
+            file.print "\n"
+
+            next_address += line_size
+          end
+          
+          file.print ":00000001FF"
+        end
+      end
+      
+      # ----------------------------------------------------------------
+
+      def self.checksum(data)
+        checksum = 0
+
+        data.scan(/../).each do |value|
+          checksum += WOoo::Util::HexUtil.to_i(value)
+        end
+
+        checksum = ((checksum & 255) ^ 255) + 1
+
+        checksum
+      end
+    end
+  end
+end

data/lib/wo_oo/electronics/intel_hex_grammar.rb

@@ -0,0 +1,486 @@
+# Autogenerated from a Treetop grammar. Edits may be lost.
+
+
+require "treetop"
+
+module WOoo
+  module Electronics
+    module IntelHex
+      include Treetop::Runtime
+
+      def root
+        @root ||= :file
+      end
+
+      module File0
+        def _lines
+          elements[0]
+        end
+
+        def eof_line
+          elements[1]
+        end
+      end
+
+      module File1
+        def eval
+          data = ""
+          _lines.elements.each do |line|
+            data += line.eval
+          end
+          data
+        end
+      end
+
+      def _nt_file
+        start_index = index
+        if node_cache[:file].has_key?(index)
+          cached = node_cache[:file][index]
+          if cached
+            cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+            @index = cached.interval.end
+          end
+          return cached
+        end
+
+        i0, s0 = index, []
+        s1, i1 = [], index
+        loop do
+          r2 = _nt_data_line
+          if r2
+            s1 << r2
+          else
+            break
+          end
+        end
+        r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
+        s0 << r1
+        if r1
+          r3 = _nt_eof_line
+          s0 << r3
+        end
+        if s0.last
+          r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+          r0.extend(File0)
+          r0.extend(File1)
+        else
+          @index = i0
+          r0 = nil
+        end
+
+        node_cache[:file][start_index] = r0
+
+        r0
+      end
+
+      module DataLine0
+        def _byte_count
+          elements[2]
+        end
+
+        def _address
+          elements[3]
+        end
+
+        def _record_type
+          elements[4]
+        end
+
+        def _data
+          elements[5]
+        end
+
+        def _checksum
+          elements[6]
+        end
+
+      end
+
+      module DataLine1
+        def eval
+          line_data = _data.text_value
+          # unless line_data.size == 
+        end
+      end
+
+      def _nt_data_line
+        start_index = index
+        if node_cache[:data_line].has_key?(index)
+          cached = node_cache[:data_line][index]
+          if cached
+            cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+            @index = cached.interval.end
+          end
+          return cached
+        end
+
+        i0, s0 = index, []
+        i1 = index
+        r2 = _nt_eof_line
+        if r2
+          r1 = nil
+        else
+          @index = i1
+          r1 = instantiate_node(SyntaxNode,input, index...index)
+        end
+        s0 << r1
+        if r1
+          if has_terminal?(":", false, index)
+            r3 = instantiate_node(SyntaxNode,input, index...(index + 1))
+            @index += 1
+          else
+            terminal_parse_failure(":")
+            r3 = nil
+          end
+          s0 << r3
+          if r3
+            r4 = _nt_byte_count
+            s0 << r4
+            if r4
+              r5 = _nt_address
+              s0 << r5
+              if r5
+                r6 = _nt_record_type
+                s0 << r6
+                if r6
+                  r7 = _nt_data
+                  s0 << r7
+                  if r7
+                    r8 = _nt_checksum
+                    s0 << r8
+                    if r8
+                      if has_terminal?("\n", false, index)
+                        r9 = instantiate_node(SyntaxNode,input, index...(index + 1))
+                        @index += 1
+                      else
+                        terminal_parse_failure("\n")
+                        r9 = nil
+                      end
+                      s0 << r9
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+        if s0.last
+          r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+          r0.extend(DataLine0)
+          r0.extend(DataLine1)
+        else
+          @index = i0
+          r0 = nil
+        end
+
+        node_cache[:data_line][start_index] = r0
+
+        r0
+      end
+
+      module ByteCount0
+        def hex_value1
+          elements[0]
+        end
+
+        def hex_value2
+          elements[1]
+        end
+      end
+
+      def _nt_byte_count
+        start_index = index
+        if node_cache[:byte_count].has_key?(index)
+          cached = node_cache[:byte_count][index]
+          if cached
+            cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+            @index = cached.interval.end
+          end
+          return cached
+        end
+
+        i0, s0 = index, []
+        r1 = _nt_hex_value
+        s0 << r1
+        if r1
+          r2 = _nt_hex_value
+          s0 << r2
+        end
+        if s0.last
+          r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+          r0.extend(ByteCount0)
+        else
+          @index = i0
+          r0 = nil
+        end
+
+        node_cache[:byte_count][start_index] = r0
+
+        r0
+      end
+
+      module Address0
+        def hex_value1
+          elements[0]
+        end
+
+        def hex_value2
+          elements[1]
+        end
+
+        def hex_value3
+          elements[2]
+        end
+
+        def hex_value4
+          elements[3]
+        end
+      end
+
+      def _nt_address
+        start_index = index
+        if node_cache[:address].has_key?(index)
+          cached = node_cache[:address][index]
+          if cached
+            cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+            @index = cached.interval.end
+          end
+          return cached
+        end
+
+        i0, s0 = index, []
+        r1 = _nt_hex_value
+        s0 << r1
+        if r1
+          r2 = _nt_hex_value
+          s0 << r2
+          if r2
+            r3 = _nt_hex_value
+            s0 << r3
+            if r3
+              r4 = _nt_hex_value
+              s0 << r4
+            end
+          end
+        end
+        if s0.last
+          r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+          r0.extend(Address0)
+        else
+          @index = i0
+          r0 = nil
+        end
+
+        node_cache[:address][start_index] = r0
+
+        r0
+      end
+
+      module RecordType0
+        def hex_value1
+          elements[0]
+        end
+
+        def hex_value2
+          elements[1]
+        end
+      end
+
+      def _nt_record_type
+        start_index = index
+        if node_cache[:record_type].has_key?(index)
+          cached = node_cache[:record_type][index]
+          if cached
+            cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+            @index = cached.interval.end
+          end
+          return cached
+        end
+
+        i0, s0 = index, []
+        r1 = _nt_hex_value
+        s0 << r1
+        if r1
+          r2 = _nt_hex_value
+          s0 << r2
+        end
+        if s0.last
+          r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+          r0.extend(RecordType0)
+        else
+          @index = i0
+          r0 = nil
+        end
+
+        node_cache[:record_type][start_index] = r0
+
+        r0
+      end
+
+      module Data0
+        def hex_value
+          elements[0]
+        end
+
+      end
+
+      def _nt_data
+        start_index = index
+        if node_cache[:data].has_key?(index)
+          cached = node_cache[:data][index]
+          if cached
+            cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+            @index = cached.interval.end
+          end
+          return cached
+        end
+
+        s0, i0 = [], index
+        loop do
+          i1, s1 = index, []
+          r2 = _nt_hex_value
+          s1 << r2
+          if r2
+            i3 = index
+            r4 = _nt_checksum
+            if r4
+              @index = i3
+              r3 = instantiate_node(SyntaxNode,input, index...index)
+            else
+              r3 = nil
+            end
+            s1 << r3
+          end
+          if s1.last
+            r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
+            r1.extend(Data0)
+          else
+            @index = i1
+            r1 = nil
+          end
+          if r1
+            s0 << r1
+          else
+            break
+          end
+        end
+        r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+
+        node_cache[:data][start_index] = r0
+
+        r0
+      end
+
+      module Checksum0
+        def hex_value1
+          elements[0]
+        end
+
+        def hex_value2
+          elements[1]
+        end
+      end
+
+      def _nt_checksum
+        start_index = index
+        if node_cache[:checksum].has_key?(index)
+          cached = node_cache[:checksum][index]
+          if cached
+            cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+            @index = cached.interval.end
+          end
+          return cached
+        end
+
+        i0, s0 = index, []
+        r1 = _nt_hex_value
+        s0 << r1
+        if r1
+          r2 = _nt_hex_value
+          s0 << r2
+        end
+        if s0.last
+          r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+          r0.extend(Checksum0)
+        else
+          @index = i0
+          r0 = nil
+        end
+
+        node_cache[:checksum][start_index] = r0
+
+        r0
+      end
+
+      def _nt_hex_value
+        start_index = index
+        if node_cache[:hex_value].has_key?(index)
+          cached = node_cache[:hex_value][index]
+          if cached
+            cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+            @index = cached.interval.end
+          end
+          return cached
+        end
+
+        i0 = index
+        if has_terminal?('\G[0-9]', true, index)
+          r1 = true
+          @index += 1
+        else
+          r1 = nil
+        end
+        if r1
+          r0 = r1
+        else
+          if has_terminal?('\G[A-F]', true, index)
+            r2 = true
+            @index += 1
+          else
+            r2 = nil
+          end
+          if r2
+            r0 = r2
+          else
+            @index = i0
+            r0 = nil
+          end
+        end
+
+        node_cache[:hex_value][start_index] = r0
+
+        r0
+      end
+
+      def _nt_eof_line
+        start_index = index
+        if node_cache[:eof_line].has_key?(index)
+          cached = node_cache[:eof_line][index]
+          if cached
+            cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+            @index = cached.interval.end
+          end
+          return cached
+        end
+
+        if has_terminal?(":00000001FF", false, index)
+          r0 = instantiate_node(SyntaxNode,input, index...(index + 11))
+          @index += 11
+        else
+          terminal_parse_failure(":00000001FF")
+          r0 = nil
+        end
+
+        node_cache[:eof_line][start_index] = r0
+
+        r0
+      end
+
+    end
+
+    class IntelHexParser < Treetop::Runtime::CompiledParser
+      include IntelHex
+    end
+
+  end
+end

data/lib/wo_oo/electronics/intel_hex_grammar.treetop

@@ -0,0 +1,56 @@
+require "treetop"
+
+module WOoo
+  module Electronics
+    grammar IntelHex
+      rule file
+        _lines:data_line* eof_line {
+          def eval
+            data = ""
+            _lines.elements.each do |line|
+              data += line.eval
+            end
+            data
+          end
+        }
+      end
+
+      rule data_line
+        !eof_line ":" _byte_count:byte_count _address:address _record_type:record_type _data:data _checksum:checksum "\n" {
+          def eval
+            line_data = _data.text_value
+            # unless line_data.size == 
+          end
+        }
+      end
+
+      rule byte_count
+        hex_value hex_value
+      end
+
+      rule address
+        hex_value hex_value hex_value hex_value
+      end
+
+      rule record_type
+        hex_value hex_value
+      end
+
+      rule data
+        (hex_value &checksum)*
+      end
+
+      rule checksum
+        hex_value hex_value
+      end
+
+      rule hex_value
+        [0-9] / [A-F]
+      end
+
+      rule eof_line
+        ":00000001FF"
+      end
+    end
+  end
+end

data/lib/wo_oo/util/hex.rb

@@ -0,0 +1,82 @@
+module WOoo
+  module Util
+    # HexUtil convert to HEX 8, 16 or 32
+    # 
+    # > WOoo::Util::HexUtil.to_hex8(11)
+    # "0B"
+    # 
+    # > WOoo::Util::HexUtil.to_hex8("11")
+    # "0B"
+    # 
+    # > WOoo::Util::HexUtil.to_hex8([11, 16, 255])
+    # ["0B", "10", "FF"]
+    # 
+    # > WOoo::Util::HexUtil.to_i("0B")
+    # 11
+    # 
+    # > WOoo::Util::HexUtil.to_i(["0B", "10", "FF"])
+    # [11, 16, 255]
+    # 
+    module HexUtil
+      HEX_8   = 0
+      HEX_16  = 1
+      HEX_32  = 2
+      
+      SPRINTF_CONFIGURATION = ["%.2x", "%.4x", "%.8x"]
+      
+      def self.to_hex8(values)
+        case values
+        when Integer
+          to_hex(values, HEX_8)
+        when Array
+          values.map { |value| to_hex8(value) }
+        when String
+           to_hex(values.to_i, HEX_8)
+        end
+      end
+      
+      # ----------------------------------------------------------------
+      
+      def self.to_hex16(values)
+        case values
+        when Integer
+          to_hex(values, HEX_16)
+        when Array
+          values.map { |value| to_hex16(value) }
+        when String
+           to_hex(values.to_i, HEX_16)
+        end
+      end
+      
+      # ----------------------------------------------------------------
+      
+      def self.to_hex32(values)
+        case values
+        when Integer
+          to_hex(values, HEX_32)
+        when Array
+          values.map { |value| to_hex32(value) }
+        when String
+           to_hex(values.to_i, HEX_32)
+        end
+      end
+      
+      # ----------------------------------------------------------------
+      
+      def self.to_hex(value, size = HEX_8)
+        sprintf(SPRINTF_CONFIGURATION[size], value).upcase
+      end
+      
+      # ----------------------------------------------------------------
+      
+      def self.to_i(values)
+        case values
+        when String
+          values.downcase.to_i(16)
+        when Array
+          values.map { |value| to_i(value) }
+        end
+      end
+    end
+  end
+end

data/spec/hex_util_spec.rb

@@ -0,0 +1,187 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require "wo_oo/util/hex"
+
+describe WOoo::Util::HexUtil do
+  context "HEX 8" do
+    before(:all) do
+      @data = {
+        1 => "01",
+        11 => "0B",
+        15 => "0F",
+        16 => "10",
+        255 => "FF"
+      }
+    end
+    
+    
+    it "convert integer to hex" do
+      @data.each do |byte, hex|
+        WOoo::Util::HexUtil.to_hex8(byte).should == hex
+      end
+    end
+
+
+
+    it "convert array of integers to array of hex" do
+      values = @data.keys
+      expected_results = @data.values
+
+      WOoo::Util::HexUtil.to_hex8(values).should == expected_results
+    end
+
+
+
+    it "convert string to hex" do
+      @data.map{ |key, value| [key.to_s, value] }.each do |byte, hex|
+        WOoo::Util::HexUtil.to_hex8(byte).should == hex
+      end
+    end
+
+
+
+    it "convert hex to integer" do
+      @data.each do |byte, hex|
+        WOoo::Util::HexUtil.to_i(hex).should == byte
+      end
+    end
+    
+    
+    
+    it "convert array of hex to array of integer" do
+      values = @data.values
+      expected_results = @data.keys
+      
+      WOoo::Util::HexUtil.to_i(values).should == expected_results
+    end
+  end
+  
+  
+  # ----------------------------------------------------------------
+  # ----------------------------------------------------------------
+  
+  
+  context "HEX 16" do
+    before(:all) do
+      @data = {
+        1 => "0001",
+        11 => "000B",
+        15 => "000F",
+        16 => "0010",
+        255 => "00FF",
+        256 => "0100",
+        437 => "01B5",
+        512 => "0200",
+        4096 => "1000",
+        20284 => "4F3C",
+        65535 => "FFFF"
+      }
+    end
+    
+    it "convert integer to hex" do
+      @data.each do |byte, hex|
+        WOoo::Util::HexUtil.to_hex16(byte).should == hex
+      end
+    end
+
+
+
+    it "convert array of integers to array of hex" do
+      values = @data.keys
+      expected_results = @data.values
+
+      WOoo::Util::HexUtil.to_hex16(values).should == expected_results
+    end
+
+
+
+    it "convert string to hex" do
+      @data.map{ |key, value| [key.to_s, value] }.each do |byte, hex|
+        WOoo::Util::HexUtil.to_hex16(byte).should == hex
+      end
+    end
+
+
+
+    it "convert hex to integer" do
+      @data.each do |byte, hex|
+        WOoo::Util::HexUtil.to_i(hex).should == byte
+      end
+    end
+    
+    
+    
+    it "convert array of hex to array of integer" do
+      values = @data.values
+      expected_results = @data.keys
+      
+      WOoo::Util::HexUtil.to_i(values).should == expected_results
+    end
+  end
+  
+  
+  # ----------------------------------------------------------------
+  # ----------------------------------------------------------------
+  
+  
+  context "HEX 32" do
+    before(:all) do
+      @data = {
+        1 =>          "00000001",
+        11 =>         "0000000B",
+        15 =>         "0000000F",
+        16 =>         "00000010",
+        255 =>        "000000FF",
+        256 =>        "00000100",
+        437 =>        "000001B5",
+        512 =>        "00000200",
+        4096 =>       "00001000",
+        20284 =>      "00004F3C",
+        65535 =>      "0000FFFF",
+        65536 =>      "00010000",
+        65567 =>      "0001001F",
+        3833132 =>    "003A7D2C",
+        4294967295 => "FFFFFFFF"
+      }
+    end
+    
+    it "convert integer to hex" do
+      @data.each do |byte, hex|
+        WOoo::Util::HexUtil.to_hex32(byte).should == hex
+      end
+    end
+
+
+
+    it "convert array of integers to array of hex" do
+      values = @data.keys
+      expected_results = @data.values
+
+      WOoo::Util::HexUtil.to_hex32(values).should == expected_results
+    end
+
+
+
+    it "convert string to hex" do
+      @data.map{ |key, value| [key.to_s, value] }.each do |byte, hex|
+        WOoo::Util::HexUtil.to_hex32(byte).should == hex
+      end
+    end
+
+
+
+    it "convert hex to integer" do
+      @data.each do |byte, hex|
+        WOoo::Util::HexUtil.to_i(hex).should == byte
+      end
+    end
+    
+    
+    
+    it "convert array of hex to array of integer" do
+      values = @data.values
+      expected_results = @data.keys
+      
+      WOoo::Util::HexUtil.to_i(values).should == expected_results
+    end
+  end
+end

data/spec/intel_hex_file_spec.rb

@@ -0,0 +1,42 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require "wo_oo/electronics/intel_hex_file"
+require "tmpdir"
+
+SAMPLE_HEX_DATA = "214601360121470136007EFE09D219012146017EB7C20001FF5F160021480119194E79234623965778239EDA3F01B2CA3F0156702B5E712B722B732146013421"
+SAMPLE_BIN_DATA = [33, 70, 1, 54, 1, 33, 71, 1, 54, 0, 126, 254, 9, 210, 25, 1, 33, 70, 1, 126, 183, 194, 0, 1, 255, 95, 22, 0, 33, 72, 1, 25, 25, 78, 121, 35, 70, 35, 150, 87, 120, 35, 158, 218, 63, 1, 178, 202, 63, 1, 86, 112, 43, 94, 113, 43, 114, 43, 115, 33, 70, 1, 52, 33]
+
+describe WOoo::Util::HexUtil do
+  before(:all) do
+    @sample_file_path = File.expand_path(File.dirname(__FILE__) + "/resources/wikipedia_sample.hex")
+  end
+  
+  
+  
+  before(:each) do
+    @temp_file_path = File.join(Dir.tmpdir, "output.hex")
+  end
+  
+  
+  
+  after(:each) do
+    File.delete(@temp_file_path) if File.exists?(@temp_file_path)
+  end
+  
+  
+  
+  it "loads an intel hex file 8-bits" do
+    WOoo::Electronics::IntelHexFile.read(@sample_file_path).should == SAMPLE_BIN_DATA
+  end
+  
+  
+  
+  it "writes to an intel hex file 8-bits" do
+    start_address = 256
+    WOoo::Electronics::IntelHexFile.write(@temp_file_path, SAMPLE_BIN_DATA, start_address)
+    
+    content = File.read(@temp_file_path)
+    expected_content = File.read(@sample_file_path)
+    
+    content.should == expected_content
+  end
+end

data/spec/resources/wikipedia_sample.hex

@@ -0,0 +1,5 @@
+:11010000214601360121470136007EFE09D21901211E
+:1101110046017EB7C20001FF5F160021480119194E40
+:1101220079234623965778239EDA3F01B2CA3F015675
+:0D013300702B5E712B722B7321460134215D
+:00000001FF

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  
+end

metadata

@@ -0,0 +1,130 @@
+--- !ruby/object:Gem::Specification 
+name: hex
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.1.0
+platform: ruby
+authors: 
+- "Fr\xC3\xA9d\xC3\xA9ric Mascaro"
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-05-22 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 2.6.0
+  type: :development
+  prerelease: false
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: yard
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 0.7.1
+  type: :development
+  prerelease: false
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 1.0.13
+  type: :development
+  prerelease: false
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: jeweler
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 1.6.0
+  type: :development
+  prerelease: false
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: rcov
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id005
+description: Convert hex data to/from integer, and read/write Intel HEX File.
+email: frederic.mascaro@wo-oo.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE.txt
+- README.rdoc
+files: 
+- .document
+- .rspec
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- VERSION
+- hex.gemspec
+- lib/wo_oo/electronics/intel_hex_file.rb
+- lib/wo_oo/electronics/intel_hex_grammar.rb
+- lib/wo_oo/electronics/intel_hex_grammar.treetop
+- lib/wo_oo/util/hex.rb
+- spec/hex_util_spec.rb
+- spec/intel_hex_file_spec.rb
+- spec/resources/wikipedia_sample.hex
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/rfred999/hex
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: -3815648496608125443
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Convert hex data to/from integer, and read/write Intel HEX File.
+test_files: []
+