binary_struct 1.0.0

data/.gitignore

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

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 binary_struct.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Red Hat, Inc.
+
+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,82 @@
+# BinaryStruct
+
+BinaryStruct is a class for dealing with binary structured data.  It simplifies
+expressing what the binary structure looks like, with the ability to name the
+parts.  Given this definition, it is easy to encode/decode the binary structure
+from/to a Hash.
+
+## Example Usage
+
+As an example, we will show reading and writing a .gif header.  This example is
+also in spec/gif_spec.rb.
+
+### Create the structure definition
+
+```ruby
+gif_header = BinaryStruct.new([
+  "a3", :magic,
+  "a3", :version,
+  "S",  :width,
+  "S",  :height,
+  "a",  :flags,
+  "C",  :bg_color_index,
+  "C",  :pixel_aspect_ratio
+])
+```
+
+### Read the header
+
+```ruby
+header_size = gif_header.size
+header = File.open("test.gif", "rb") { |f| f.read(header_size) }
+gif_header.decode(header)
+
+=> {
+  :magic              => "GIF",
+  :version            => "89a",
+  :width              => 16,
+  :height             => 16,
+  :flags              => "\x80",
+  :bg_color_index     => 0,
+  :pixel_aspect_ratio => 0
+}
+```
+
+### Write the header
+
+```ruby
+header = gif_header.encode({
+  :magic              => "GIF",
+  :version            => "89a",
+  :width              => 16,
+  :height             => 16,
+  :flags              => "\x80",
+  :bg_color_index     => 0,
+  :pixel_aspect_ratio => 0
+})
+File.open("test.gif", "wb") { |f| f.write(header) }
+
+=> "GIF89a\x10\x00\x10\x00\x80\x00\x00"
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'binary_struct'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install binary_struct
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,5 @@
+require "bundler/gem_tasks"
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new('spec')
+task :test => :spec

data/binary_struct.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'binary_struct/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "binary_struct"
+  spec.version       = BinaryStruct::VERSION
+  spec.authors       = ["Oleg Barenboim", "Jason Frey"]
+  spec.email         = ["chessbyte@gmail.com", "fryguy9@gmail.com"]
+  spec.description   = %q{
+BinaryStruct is a class for dealing with binary structured data.  It simplifies
+expressing what the binary structure looks like, with the ability to name the
+parts.  Given this definition, it is easy to encode/decode the binary structure
+from/to a Hash.
+}
+  spec.summary       = %q{BinaryStruct is a class for dealing with binary structured data.}
+  spec.homepage      = "http://github.com/ManageIQ/binary_struct"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+end

data/lib/binary_struct.rb

@@ -0,0 +1,189 @@
+require "binary_struct/version"
+require "enumerator"
+
+class BinaryStruct
+  SIZES = {
+    'A'   => 1,   # String with trailing NULs and spaces removed
+    'a'   => 1,   # String
+    'B'   => nil, # Extract bits from each character (MSB first)
+    'b'   => nil, # Extract bits from each character (LSB first)
+    'C'   => 1,   # Extract a character as an unsigned integer
+    'c'   => 1,   # Extract a character as a    signed integer
+    'E'   => nil, # Treat sizeof(double) characters as a double in little-endian byte order
+    'e'   => nil, # Treat sizeof(float)  characters as a float  in little-endian byte order
+    'G'   => nil, # Treat sizeof(double) characters as a double in network       byte order
+    'g'   => nil, # Treat sizeof(float)  characters as a float  in network       byte order
+    'H'   => nil, # Extract hex nibbles from each character (most  significant first)
+    'h'   => nil, # Extract hex nibbles from each character (least significant first)
+    'I'   => 4,   # Treat sizeof(int) successive characters as an unsigned native integer
+    'i'   => 4,   # Treat sizeof(int) successive characters as a    signed native integer
+    'L'   => 4,   # Treat 4 successive characters as an unsigned native long integer
+    'l'   => 4,   # Treat 4 successive characters as a    signed native long integer
+    'M'   => 1,   # Extract a quoted printable string
+    'm'   => 1,   # Extract a Base64 encoded string
+    'N'   => 4,   # Treat 4 characters as an unsigned long  in network byte order
+    'n'   => 2,   # Treat 2 characters as an unsigned short in network byte order
+    'P'   => nil, # Treat sizeof(char *) characters as a pointer, and return len characters from the referenced location
+    'p'   => nil, # Treat sizeof(char *) characters as a pointer to a null-terminated string
+    'Q'   => 8,   # Treat 8 characters as an unsigned quad word (64 bits)
+    'q'   => 8,   # Treat 8 characters as a    signed quad word (64 bits)
+    'S'   => 2,   # Treat 2 successive characters as an unsigned short in native byte order
+    's'   => 2,   # Treat 2 successive characters as a    signed short in native byte order
+    'U'   => nil, # Extract UTF-8 characters as unsigned integers
+    'u'   => nil, # Extract a UU-encoded string
+    'V'   => 4,   # Treat 4 characters as an unsigned long  in little-endian byte order
+    'v'   => 2,   # Treat 2 characters as an unsigned short in little-endian byte order
+    'w'   => nil, # BER-compressed integer
+    'X'   => -1,  # Skip backward one character
+    'x'   => 1,   # Skip forward  one character
+    'Z'   => 1,   # String with trailing NULs removed
+  }
+
+  STRING_FORMATS = %w{A a M m u}
+
+  def initialize(definition = nil)
+    self.definition = definition unless definition.nil?
+  end
+
+  def definition
+    @definition
+  end
+
+  def definition=(value)
+    if value.kind_of?(self.class)
+      @definition = value.definition.dup
+    else
+      value = Array(value)
+      self.class.validate_definition(value)
+      @definition = value
+    end
+    @size = @decode_format = @decode_name = nil
+  end
+
+  def size
+    @size ||= self.class.get_size(@definition)
+  end
+
+  def decode(data, num = 1)
+    values = self.decode_to_array(data, num)
+    return self.decoded_array_to_hash!(values) if num == 1
+
+    result = []
+    num.times { result << self.decoded_array_to_hash!(values) }
+    return result
+  end
+
+  def decode_to_array(data, num = 1)
+    raise ArgumentError, "data cannot be nil" if data.nil?
+    @decode_format, @decode_names = self.class.prep_decode(@definition) if @decode_format.nil?
+    format = (num == 1) ? @decode_format : @decode_format * num
+    return data.unpack(format)
+  end
+
+  def decoded_array_to_hash!(array)
+    hash = {}
+    @decode_names.each do |k|
+      v = array.shift
+      next if k.nil?
+      hash[k] = v
+    end
+    return hash
+  end
+
+  def encode(hash)
+    return encode_hash(hash) unless hash.kind_of?(Array)
+
+    data = ""
+    hash.each { |h| data << self.encode_hash(h) }
+    return data
+  end
+
+  def encode_hash(hash)
+    data = ""
+    @definition.each_slice(2) do |format, name|
+      raise "member not found: #{name}" unless name.nil? || hash.has_key?(name)
+      value = unless name.nil?
+        hash[name]
+      else
+        STRING_FORMATS.include?(format[0, 1]) ? '0' : 0
+      end
+      data << [value].pack(format)
+    end
+    return data
+  end
+
+  def ==(other)
+    self.definition == other.definition
+  end
+
+  def each(&block)
+    self.definition.each_slice(2, &block)
+  end
+
+  #
+  # Methods to handle the old style of calling
+  #
+
+  @@structs_by_definition = {}
+
+  def self.clear_structs_by_definition_cache
+    @@structs_by_definition.clear
+  end
+
+  def self.sizeof(definition)
+    d = @@structs_by_definition[definition]
+    d = @@structs_by_definition[definition] = definition.kind_of?(self) ? definition : self.new(definition) if d.nil?
+    d.size
+  end
+
+  def self.decode(data, definition)
+    d = @@structs_by_definition[definition]
+    d = @@structs_by_definition[definition] = definition.kind_of?(self) ? definition : self.new(definition) if d.nil?
+    d.decode(data)
+  end
+
+  def self.encode(hash, definition)
+    d = @@structs_by_definition[definition]
+    d = @@structs_by_definition[definition] = definition.kind_of?(self) ? definition : self.new(definition) if d.nil?
+    d.encode(hash)
+  end
+
+  private
+
+  def self.validate_definition(definition)
+    raise "definition must be an array of format/name pairs" if definition.empty? || definition.length % 2 != 0
+    definition.each_slice(2) do |format, name|
+      type, count = format[0, 1], format[1..-1]
+      raise "unrecognized format: #{type}" unless SIZES.has_key?(type)
+      raise "unsupported format: #{type}" if SIZES[type].nil?
+      unless count.empty? || count == '*'
+        begin
+          count = Integer(count)
+        rescue
+          raise "unsupported count: #{count}"
+        end
+        raise "unsupported count: #{count}" if count < 0
+      end
+    end
+  end
+
+  def self.get_size(definition)
+    size = 0
+    definition.each_slice(2) do |format, name|
+      type, count = format[0, 1], format[1..-1]
+      count = count.empty? ? 1 : count.to_i
+      size += (count * SIZES[type])
+    end
+    return size
+  end
+
+  def self.prep_decode(definition)
+    formats = ""
+    names = []
+    definition.each_slice(2) do |format, name|
+      formats << format
+      names << name
+    end
+    return formats, names
+  end
+end

data/lib/binary_struct/version.rb

@@ -0,0 +1,3 @@
+class BinaryStruct
+  VERSION = "1.0.0"
+end

data/spec/binary_struct_spec.rb

@@ -0,0 +1,110 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
+
+require 'binary_struct'
+
+describe BinaryStruct do
+  STRUCT_DEF = [
+    'Q', :quad,
+    'L', 'long',
+    'S', :short,
+    'C', nil,
+    'a0', 'none',
+    'a', nil,
+    'a2', 'bc',
+  ]
+  STRUCT_DEF_SIZE = 18
+
+  STRUCT_DEF_ASTERISK = ['a*', :word]
+  STRUCT_DEF_ASTERISK_SIZE = 0 # '*' is ignored
+
+  STRUCT_DEF_UNRECOGNIZED_FORMAT   = ['D', nil]
+  STRUCT_DEF_UNSUPPORTED_FORMAT    = ['B', nil]
+  STRUCT_DEF_UNSUPPORTED_COUNT_NEG = ['a-1', nil]
+  STRUCT_DEF_UNSUPPORTED_COUNT_INV = ['aX', nil]
+
+  STRUCT_ENCODED_STR  = "\000\111\222\333\444\555\666\777\000\111\222\333\000\111\0000BC"
+  STRUCT_DECODED_HASH = {:quad=>18426034930503010560, "long"=>3683797248, :short=>18688, "bc"=>"BC", "none"=>""}
+
+  it('.new') { lambda { BinaryStruct.new }.should_not raise_error }
+  it('.new with definition') { lambda { BinaryStruct.new(STRUCT_DEF) }.should_not raise_error }
+  it('.new with definition with *') { lambda { BinaryStruct.new(STRUCT_DEF_ASTERISK) }.should_not raise_error }
+  it '.new with another BinaryStruct' do
+    s = BinaryStruct.new(STRUCT_DEF)
+    s2 = BinaryStruct.new(s)
+    s2.should == s
+    s2.should_not equal(s)
+  end
+
+  it('.new with unrecognized format')        { lambda { BinaryStruct.new(STRUCT_DEF_UNRECOGNIZED_FORMAT) }.should   raise_error(RuntimeError) }
+  it('.new with unsupported format')         { lambda { BinaryStruct.new(STRUCT_DEF_UNSUPPORTED_FORMAT) }.should    raise_error(RuntimeError) }
+  it('.new with unsupported negative count') { lambda { BinaryStruct.new(STRUCT_DEF_UNSUPPORTED_COUNT_NEG) }.should raise_error(RuntimeError) }
+  it('.new with unsupported invalid count')  { lambda { BinaryStruct.new(STRUCT_DEF_UNSUPPORTED_COUNT_INV) }.should raise_error(RuntimeError) }
+
+  it('#definition=') { lambda { BinaryStruct.new.definition = STRUCT_DEF }.should_not raise_error }
+  it('#definition= with definition with *') { lambda { BinaryStruct.new.definition = STRUCT_DEF_ASTERISK }.should_not raise_error }
+
+  it('#definition= with unrecognized format')        { lambda { BinaryStruct.new.definition = STRUCT_DEF_UNRECOGNIZED_FORMAT }.should   raise_error(RuntimeError) }
+  it('#definition= with unsupported format')         { lambda { BinaryStruct.new.definition = STRUCT_DEF_UNSUPPORTED_FORMAT }.should    raise_error(RuntimeError) }
+  it('#definition= with unsupported negative count') { lambda { BinaryStruct.new.definition = STRUCT_DEF_UNSUPPORTED_COUNT_NEG }.should raise_error(RuntimeError) }
+  it('#definition= with unsupported invalid count')  { lambda { BinaryStruct.new.definition = STRUCT_DEF_UNSUPPORTED_COUNT_INV }.should raise_error(RuntimeError) }
+
+  it('#size') { BinaryStruct.new(STRUCT_DEF).size.should == STRUCT_DEF_SIZE }
+  it('#size with definition with *') { BinaryStruct.new(STRUCT_DEF_ASTERISK).size.should == STRUCT_DEF_ASTERISK_SIZE }
+
+  it '#decode' do
+    BinaryStruct.new(STRUCT_DEF).decode(STRUCT_ENCODED_STR).should == STRUCT_DECODED_HASH
+  end
+
+  it '#decode with definition with *' do
+    BinaryStruct.new(STRUCT_DEF_ASTERISK).decode("Testing").should == {:word => "Testing"}
+  end
+
+  it '#decode against multiple records' do
+    BinaryStruct.new(STRUCT_DEF).decode(STRUCT_ENCODED_STR * 10, 10).should == [STRUCT_DECODED_HASH] * 10
+  end
+
+  it '#encode' do
+    BinaryStruct.new(STRUCT_DEF).encode(STRUCT_DECODED_HASH).should == STRUCT_ENCODED_STR
+  end
+
+  it '#encode with definition with *' do
+    BinaryStruct.new(STRUCT_DEF_ASTERISK).encode({:word => "Testing"}).should == "Testing"
+  end
+
+  it '#encode against multiple records' do
+    BinaryStruct.new(STRUCT_DEF).encode([STRUCT_DECODED_HASH] * 10).should == (STRUCT_ENCODED_STR * 10)
+  end
+
+  it '#== against another BinaryStruct' do
+    BinaryStruct.new(STRUCT_DEF).should     == BinaryStruct.new(STRUCT_DEF)
+    BinaryStruct.new(STRUCT_DEF).should_not == BinaryStruct.new(STRUCT_DEF_ASTERISK)
+  end
+
+  it '#each will iterate over definition' do
+    dup_def = []
+    BinaryStruct.new(STRUCT_DEF).each { |field, name| dup_def << field << name }
+    dup_def.should == STRUCT_DEF
+  end
+
+  context "old style methods" do
+    after(:each) { BinaryStruct.clear_structs_by_definition_cache }
+
+    it '#sizeof' do
+      BinaryStruct.sizeof(STRUCT_DEF).should == STRUCT_DEF_SIZE
+      # Do it twice for consistency reasons
+      BinaryStruct.sizeof(STRUCT_DEF).should == STRUCT_DEF_SIZE
+    end
+
+    it '#decode' do
+      BinaryStruct.decode(STRUCT_ENCODED_STR, STRUCT_DEF).should == STRUCT_DECODED_HASH
+      # Do it twice for consistency reasons
+      BinaryStruct.decode(STRUCT_ENCODED_STR, STRUCT_DEF).should == STRUCT_DECODED_HASH
+    end
+
+    it '#encode' do
+      BinaryStruct.encode(STRUCT_DECODED_HASH, STRUCT_DEF).should == STRUCT_ENCODED_STR
+      # Do it twice for consistency reasons
+      BinaryStruct.encode(STRUCT_DECODED_HASH, STRUCT_DEF).should == STRUCT_ENCODED_STR
+    end
+  end
+end

data/spec/gif_spec.rb

@@ -0,0 +1,47 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
+
+require 'binary_struct'
+
+describe BinaryStruct do
+  let(:gif_header) do
+    BinaryStruct.new([
+      "a3", :magic,
+      "a3", :version,
+      "S",  :width,
+      "S",  :height,
+      "a",  :flags,
+      "C",  :bg_color_index,
+      "C",  :pixel_aspect_ratio
+    ])
+  end
+
+  it "read a gif header" do
+    filename = File.join(File.dirname(__FILE__), %w{data test.gif})
+
+    header_size = gif_header.size
+    header = File.open(filename, "rb") { |f| f.read(header_size) }
+    gif_header.decode(header).should == {
+      :magic              => "GIF",
+      :version            => "89a",
+      :width              => 16,
+      :height             => 16,
+      :flags              => "\x80",
+      :bg_color_index     => 0,
+      :pixel_aspect_ratio => 0
+    }
+  end
+
+  it "write a gif header" do
+    header = gif_header.encode({
+      :magic              => "GIF",
+      :version            => "89a",
+      :width              => 16,
+      :height             => 16,
+      :flags              => "\x80",
+      :bg_color_index     => 0,
+      :pixel_aspect_ratio => 0
+    })
+
+    header.should == "GIF89a\x10\x00\x10\x00\x80\x00\x00"
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# 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
+
+  # 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

metadata

@@ -0,0 +1,129 @@
+--- !ruby/object:Gem::Specification
+name: binary_struct
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Oleg Barenboim
+- Jason Frey
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-04-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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'
+- !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: ! '
+
+  BinaryStruct is a class for dealing with binary structured data.  It simplifies
+
+  expressing what the binary structure looks like, with the ability to name the
+
+  parts.  Given this definition, it is easy to encode/decode the binary structure
+
+  from/to a Hash.
+
+'
+email:
+- chessbyte@gmail.com
+- fryguy9@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- binary_struct.gemspec
+- lib/binary_struct.rb
+- lib/binary_struct/version.rb
+- spec/binary_struct_spec.rb
+- spec/data/test.gif
+- spec/gif_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/ManageIQ/binary_struct
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 1202061900940413800
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 1202061900940413800
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: BinaryStruct is a class for dealing with binary structured data.
+test_files:
+- spec/binary_struct_spec.rb
+- spec/data/test.gif
+- spec/gif_spec.rb
+- spec/spec_helper.rb