packed_struct 0.2.1 → 0.3.0

data/README.md

@@ -1,4 +1,4 @@
-# PackedStruct
+# PackedStruct [![Build Status](https://travis-ci.org/redjazz96/packed_struct.png?branch=master)](https://travis-ci.org/redjazz96/packed_struct)
 
 `PackedStruct` is a way to define packing strings (see [`Array#pack`](http://ruby-doc.org/core-2.0/Array.html#method-i-pack)).
 It was created after @charliesome suggested [a format](https://gist.github.com/redjazz96/6dda0554f62e4f77253a) for defining these strings, but never finished it.
@@ -10,6 +10,7 @@ class RconPacket
   include PackedStruct
   struct_layout :packet do
     little_endian signed size[32] # defaults to a number of size 32.
+                                  # also the same as: `little_endian signed long size`
     little_endian signed id[32]
     little_endian signed type[32]
     string body[size]
@@ -31,3 +32,12 @@ You can also unpack strings.
 RconPacket.structs[:packet].unpack("\v\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00hello world\x00")
 # => {:size => 11, :id => 1, :type => 0, :body => "hello world"}
 ```
+
+From sockets, too.  Anything that responds to `#read`.
+
+```Ruby
+file = File.open("/path/to/some/file", "r")
+
+RconPacket.structs[:packet].unpack_from_socket(file)
+# => ...
+```

data/lib/packed_struct.rb

@@ -1,15 +1,33 @@
 require 'packed_struct/package'
 require 'packed_struct/directive'
+require 'packed_struct/modifier'
 
+# Create structs to manage packed strings.
 module PackedStruct
 
+  # The structs that were defined on the module that included this.
+  # If the structs were defined without a name, this will be the one
+  # and only struct that was defined (or the last one that was
+  # defined).
+  #
+  # @return [Package, Hash<Symbol, Package>]
   def structs
     @structs ||= {}
   end
 
+  alias_method :struct, :structs
+
+  # Define a struct.  The name will be used for {#structs}, and the
+  # block will run in the context of a {Package}.
+  #
+  # @yield []
+  # @param name [Symbol, nil] the name of the struct.  If it's nil, it
+  #   is set as the only struct of the included module.
+  # @return (see #structs)
   def struct_layout(name = nil, &block)
     structs[name] = Package.new
     structs[name].instance_exec &block
+    structs[name].finalize_directives!
 
     if name == nil
       @structs = structs[name]
@@ -18,6 +36,11 @@ module PackedStruct
     structs
   end
 
+  # Called when this is included into another module.
+  #
+  # @api private
+  # @param reciever [Module] the reciever that included this one.
+  # @return [void]
   def self.included(reciever)
     reciever.extend self
   end

data/lib/packed_struct/directive.rb

@@ -1,8 +1,6 @@
-module PackedStruct
+require 'set'
 
-  # Contains information about a directive.  A directive can be a name
-  # of the type, the endian(ness) of the type, the type of the type
-  # (short, int, long, etc.), and the signed(ness) of the type.
+module PackedStruct
   class Directive
 
     # The name of the directive.  This is passed as the first value of
@@ -11,249 +9,168 @@ module PackedStruct
     # @return [Symbol]
     attr_reader :name
 
-    # The arguments passed to the directive.
-    #
-    # @return [Array<Object>]
-    attr_reader :options
-
-    # The tags the directive has, such as type, signed(ness),
-    # endian(ness), and size.  Not filled until {#to_s} is called.
-    #
-    # @return [Hash]
-    attr_accessor :tags
-
-    # The children of this directive.  If this directive has a parent,
-    # this is nil.
-    #
-    # @return [nil, Array<Directive>]
-    attr_reader :subs
-
-    # The parent of this directive.  The relationship is such that
-    # +parent.subs.include?(self)+ is true.  If this has a parent, it
-    # is nil.
+    # The modifiers for this directive.
     #
-    # @return [nil, Directive]
-    attr_accessor :parent
+    # @return [Set<Modifier>]
+    attr_reader :modifiers
 
-    # The value this directive holds.  Only for use when packing.
+    # Metadata about the directive.  Created when {#finalize!} is
+    # called.
     #
-    # @return [nil, Object]
-    attr_writer :value
-
-    # @!parse
-    #   attr_reader :value
-    def value
-      @value || (@tags[:original].value if @tags[:original])
-    end
+    # @return [Hash<Symbol, Object>]
+    attr_reader :tags
 
     # Initialize the directive.
     #
     # @param name [Symbol] the name of the directive.
-    def initialize(name, *arguments)
+    # @param package [Package] the package this directive is a part
+    #   of.
+    def initialize(name)
       @name = name
-
-      @options = arguments
-      @tags    = {}
-      @subs    = []
-      @parent  = nil
-      @value   = nil
-
-      if arguments.first.is_a? Directive
-        arguments.first.add_child(self)
-        @subs = nil
-      end
+      @modifiers = []
+      @finalized = true
+
+      @tags = {
+        :endian     => :native,
+        :signedness => :signed,
+        :size       => nil,
+        :precision  => :single,
+        :size_mod   => 0
+      }
     end
 
-    # Add a child to this (or its parent's) directive.  If this is a
-    # child itself, it adds it to the parent of this.  Invalidates the
-    # caches for {#sub_names} and {#to_s}
+    # Determines whether or not this directive is empty.  It is
+    # considered empty when its tags has all of the default values,
+    # it has no modifiers, and its name is not +:null+.
     #
-    # @param child [Directive] the child to add.
-    # @return [Directive] the child.
-    def add_child(child)
-      if @parent
-        @parent.add_child(child)
-      else
-        @_str = nil
-        @_sub_types = nil
-        @subs << child
-        child.parent = self
-        child
-      end
+    # @return [Boolean]
+    def empty?
+      tags == { :endian => :native, :signedness => :signed,
+        :size => nil, :precision => :single, :size_mod => 0
+      } && modifiers.length == 0 && name != :null
     end
 
-    # Set the size of this directive.
+    # Add a modifier to this directive.
     #
+    # @param mod [Modifier]
     # @return [self]
-    def [](size)
-      @tags[:size] = size
+    def add_modifier(mod)
+      @finalized = false
+      modifiers << mod
       self
     end
 
-    # Turn the directive into a string.  Analyzes the subs before
-    # determining information, then outputs that.  Caches the value
-    # until {#add_child} is next called.
+    # Changes the size of the directive to the given size.  It is
+    # possible for the given value to the a directive; if it is,
+    # it just uses the name of the directive.
     #
-    # @return [String]
-    def to_s
-      return "" unless @subs
-      @subs.compact!
-      @tags[:signed]   = determine_signed
-      @tags[:type]     = determine_type
-      @tags[:endian]   = determine_endian
-      "#{make_directive}#{make_length}"
-    end
-
-    # Inspects the directive.
-    #
-    # @return [String]
-    def inspect
-      "#<#{self.class.name}:#{name}>"
-    end
+    # @param new_size [Numeric, Directive]
+    # @return [self]
+    def [](new_size)
+      if new_size.is_a? Directive
+        tags.merge! new_size.tags_for_sized_directive
+      else
+        tags[:size] = new_size
+      end
 
-    # To show the size of something else, relative to this directive.
-    #
-    # @return [Directive]
-    def -(other)
-      dir = dup
-      dir.tags = tags.dup
-      dir.tags[:original   ] = self
-      dir.tags[:size_modify] = -other
-      dir
+      self
     end
 
-    # To show the size of something else, relative to this directive.
+    # Returns a hash to be merged into the tags of a directive that
+    # recieved this directive for a size.
     #
-    # @return [Directive]
-    def +(other)
-      dir = dup
-      dir.tags = tags.dup
-      dir.tags[:original   ] = self
-      dir.tags[:size_modify] = +other
-      dir
+    # @return [Hash<Symbol, Object>]
+    def tags_for_sized_directive
+      {
+        :size => name,
+        :size_mod => tags[:size_mod]
+      }
     end
 
-    # The number of bytes this takes up in the resulting packed string.
+    # Modifies +self+ such that it sizes itself (on {#to_s}ing), and
+    # keeping this size modification in mind.  In other words, this
+    # is meant to be used in another directive's {#[]} method for
+    # telling it what size it should be, and this method modifies that
+    # size by the given amount.
     #
-    # @return [Numeric]
-    def bytesize
-      case @tags[:type]
-      when nil
-        size / 8
-      when :short
-        2
-      when :int
-        4
-      when :long
-        4
-      when :float
-        if sub_names.include?(:double)
-          8
-        else
-          4
-        end
-      when :null
-        size || 1
-      when :string
-        size
+    # @example
+    #   some_directive[another_directive - 5]
+    # @param other [Numeric, #coerce]
+    # @return [self, Object]
+    def -(other)
+      if other.is_a? Numeric
+        tags[:size_mod] = -other
+        self
       else
-        0
+        self_equiv, arg_equiv = other.coerce(self)
+        self_equiv - arg_equiv
       end
     end
 
-    private
-
-    # Returns all of the names of the subs, and caches it.
-    #
-    # @param force [Boolean] force reloading the names of the subs.
-    # @return [Array<Symbol>]
-    def sub_names(force = false)
-      if @_sub_types && !force
-        @_sub_types
+    # (see #-)
+    def +(other)
+      if other.is_a? Numeric
+        tags[:size_mod] = +other
+        self
       else
-        @subs.map(&:name) + [@name]
+        self_equiv, arg_equiv = other.coerce(self)
+        self_equiv + arg_equiv
       end
     end
 
-    # Determines the size of the directive by checking if it's in the
-    # tags, or by searching the subs.
+    # Coerces +self+ into a format that can be used with +Numeric+ to
+    # add or subtract from this class.
     #
-    # @return [Numeric]
-    def size
-      case @tags[:size]
-      when Directive
-        (@tags[:size].value || 0).to_i + (@tags[:size].tags[:size_modify] || 0).to_i
-      when Numeric
-        @tags[:size]
-      when nil
-        @subs.select { |s| s && s.tags[:size] }.map { |s| s.tags[:size] }.last
-      end
+    # @example
+    #   some_directive[1 + another_directive]
+    # @param other [Object]
+    # @return [Array<(self, Object)>]
+    def coerce(other)
+      [self, other]
     end
 
-    # Determine the type of this directive.  Uses {#sub_names} to
-    # search for matching types.  Defaults to +nil+.
+    # Whether or not this directive has finalized.  It is finalized
+    # until a modifier is added, and then {#finalize!} is required to
+    # finalize the directive.
     #
-    # @return [nil, Symbol] the return value can be any of +:short+,
-    #   +:int+, +:long+, +:string+, +:float+, or +nil+.
-    def determine_type
-      case true
-      when sub_names.include?(:short)
-        :short
-      when sub_names.include?(:int)
-        :int
-      when sub_names.include?(:long)
-        :long
-      when sub_names.include?(:char), sub_names.include?(:string)
-        :string
-      when sub_names.include?(:float)
-        :float
-      when sub_names.include?(:null)
-        :null
-      else
-        nil
-      end
+    # @return [Boolean]
+    def finalized?
+      @finalized
     end
 
-    # Determines the endianness of this directive.  Uses {#sub_names}
-    # to search for matching names.  Defaults to +:native+.
+    # Finalizes the directive.
     #
-    # @return [Symbol] the return value can be any of +:little+,
-    #   +:big+, or +:native+.
-    def determine_endian
-      case true
-      when sub_names.include?(:little), sub_names.include?(:little_endian),
-        sub_names.include?(:lsb), sub_names.include?(:low)
-        :little
-      when sub_names.include?(:big), sub_names.include?(:big_endian),
-        sub_names.include?(:msb), sub_names.include?(:high),
-        sub_names.include?(:network)
-        :big
-      else
-        :native
+    # @return [void]
+    def finalize!
+      return if finalized?
+
+      modifiers.each do |modifier|
+        case modifier.type
+        when :endian, :signedness, :precision, :type, :string_type
+          tags[modifier.type] = modifier.value
+        when :size
+          tags[:size] = modifier.value unless tags[:size]
+        else
+          raise UnknownModifierError,
+            "Unknown modifier: #{modifier.type}"
+        end
       end
-    end
 
-    # Determines the signedness of this directive.  Uses {#sub_names}
-    # to search for matching names.  Defaults to +:signed+.
-    #
-    # @return [Symbol] the return value can be any of +:unsigned+ or
-    #   +:signed+.
-    def determine_signed
-      if sub_names.include?(:unsigned) && !sub_names.include?(:null)
-        :unsigned
-      else
-        :signed
-      end
+      @finalized = true
+      cache_string
     end
 
-    # Determines the directive to be used in the pack string, using
-    # the type from {#determine_type} to manage it.
+    # Turn the directive into a string, with the given data.  It
+    # shouldn't need the data unless +tags[:size]+ is a Symbol.
     #
-    # @return [String] the directive for the pack string.
-    def make_directive
-      case @tags[:type]
-      when nil
-        handle_nil_type
+    # @param data [Hash<Symbol, Object>] the data that may be used for
+    #   the length.
+    # @return [String]
+    def to_s(data = {})
+      return @_cache if !tags[:size].is_a?(Symbol) && @_cache
+      return "x" * (tags[:size] || 1) if name == :null
+
+      out = case tags[:type]
       when :short
         modify_if_needed "S"
       when :int
@@ -264,119 +181,185 @@ module PackedStruct
         handle_string_type
       when :float
         handle_float_type
-      when :null
-        "x" * (size || 1)
+      when nil
+        handle_empty_type
       else
         nil
       end
+
+      if tags[:size].is_a? Symbol
+        out << data.fetch(tags[:size]).to_s
+      elsif tags[:size] && ![:null, nil].include?(tags[:type])
+        out << tags[:size].to_s
+      end
+
+      out
     end
 
-    # Determines the length to be added to the pack string.
+    # The number of bytes a type takes up in the string.
+    BYTES_IN_STRING = {
+      :char  => [0].pack("c").bytesize,
+      :short => [0].pack("s").bytesize,
+      :int   => [0].pack("i").bytesize,
+      :long  => [0].pack("l").bytesize,
+      :float_single => [0].pack("f").bytesize,
+      :float_double => [0].pack("D").bytesize,
+    }
+
+    # The number of bytes this takes up in the resulting packed string.
     #
-    # @return [String]
-    def make_length
-      if size && ![:null, nil].include?(@tags[:type])
-        size.to_s
+    # @param (see #to_s)
+    # @return [Numeric]
+    def bytesize(data = {})
+      case tags[:type]
+      when nil
+        (size(data) || 8) / 8
+      when :short, :int, :long
+        BYTES_IN_STRING.fetch tags[:type]
+      when :float
+        if tags[:precision] == :double
+          BYTES_IN_STRING[:float_double]
+        else
+          BYTES_IN_STRING[:float_single]
+        end
+      when :null
+        size(data) || 1
+      when :string
+        size(data)
       else
-        ""
+        0
       end
     end
 
-    # Handles the nil type.  Uses the size to match the type with
-    # the directive.
+    # The size of this directive.
     #
+    # @param (see #to_s)
+    # @return [nil, Numeric]
+    def size(data = {})
+      if tags[:size].is_a? Symbol
+        data.fetch(tags[:size])
+      else
+        tags[:size]
+      end
+    end
+
+    private
+
+    # Tries to cache the string value of this directive.  It cannot if
+    # +tags[:size]+ is a Symbol, since it depends on the value of the
+    # directive named by that symbol.
+    #
+    # @return [String]
+    def cache_string
+      return if tags[:size].is_a? Symbol
+      return @_cache = "x" * (tags[:size] || 1) if name == :null
+
+      @_cache = to_s
+    end
+
+    # Handles the type if there is no type, i.e. a type modifier was
+    # not specified.  Can only handle directives with sizes
+    # 0 (default), 8, 16, 32, and 64.
+    #
+    # @see #modify_if_needed
     # @return [String]
-    def handle_nil_type
+    def handle_empty_type
       maps = {
+        0  => "x",
         8  => "C",
         16 => "S",
         32 => "L",
         64 => "Q"
       }
 
-      raise StandardError,
-        "Cannot make number of #{size} length" unless
-          maps.keys.include?(size)
-
-      modify_if_needed maps[size]
+      modify_if_needed maps.fetch(tags[:size] || 0), tags[:size] != 8
     end
 
-    # Handles a string type.  If the name of the directive is
-    # +:null+, returns a string containing a number of +x+s (nulls)
-    # exactly equal to the size (or 1, if it doesn't exist).
-    # Otherwise, determines the type of string from the sub names;
-    # types of strings can include +:hex+, +:base64+, +:bit+, or
-    # +:binary+ (defaults to binary).
+    # Handles the type if it is string.  Defaults to a null-padded
+    # string, but if a +:hex+, +:base64+, or +:bit+ modifier is
+    # specified, it will be used.
     #
-    # @return [String]
+    # If +:hex+ is specified, the endianness will be used to determine
+    # which nibble will go first.
+    #
+    # If +:base64+ is specified, the endianness will be used to
+    # determine whether +MSB+ or the +LSB+ will go first.
     def handle_string_type
-
-      case true
-      when sub_names.include?(:hex)
-        modify_if_needed "H"
-      when sub_names.include?(:base64)
+      case tags[:string_type]
+      when :hex
+        modify_for_endianness "H", true
+      when :base64
         "m"
-      when sub_names.include?(:bit)
-        modify_if_needed "B", false
+      when :bit
+        modify_for_endianness "B", true
       else
-        modify_if_needed "A", false
+        modify_for_endianness "a", true
       end
     end
 
-    # Handles float types.  Can handle double- or single- precision
-    # floats, and manage their byte order.
+    # Handles the float type.  Handles the endianness and the
+    # precision, returning the correct character for the float type.
     #
     # @return [String]
     def handle_float_type
-      double = sub_names.include?(:double)
-
-      case @tags[:endian]
-      when :native
-        if double
-          "D"
-        else
-          "F"
-        end
-      when :little
-        if double
-          "E"
-        else
-          "e"
-        end
-      when :big
-        if double
-          "G"
-        else
-          "g"
-        end
+      case [tags[:endian], tags[:precision]]
+      when [:native, :double]
+        "D"
+      when [:native, :single]
+        "F"
+      when [:little, :double]
+        "E"
+      when [:little, :single]
+        "e"
+      when [:big, :double]
+        "G"
+      when [:big, :single]
+        "g"
       end
     end
 
-    # Modifies the given string as needed; it assumes that a lowercase
-    # letter stands for a signed type and the given string stands for
-    # an unsigned type.  It also assumes that "<" added means little
-    # endian, and that ">" added means big endian (and that nothing
-    # added stands for native).
+    # Modifies the given string if it's needed, according to
+    # signness and endianness.  This assumes that a signed
+    # directive should be in lowercase.
     #
-    # @param str [String]
+    # @param str [String] the string to modify.
+    # @param include_endian [Boolean] whether or not to include the
+    #   endianness.
     # @return [String]
     def modify_if_needed(str, include_endian = true)
-      base = if @tags[:signed] == :signed
-        str.downcase
+      base = if @tags[:signedness] == :signed
+        str.swapcase
       else
         str
       end
-
-      base += case @tags[:endian]
-      when :little
-        "<"
-      when :big
-        ">"
+      if include_endian
+        modify_for_endianness(base)
       else
-        ""
-      end if include_endian
+        base
+      end
+    end
 
-      base
+    # Modifies the given string to account for endianness.  If
+    # +use_case+ is true, it modifies the case of the given string to
+    # represent endianness; otherwise, it appends data to the string
+    # to represent endianness.
+    #
+    # @param str [String] the string to modify.
+    # @param use_case [Boolean]
+    # @return [String]
+    def modify_for_endianness(str, use_case = false)
+      case [tags[:endian], use_case]
+      when [:little, true]
+        str.swapcase
+      when [:little, false]
+        str + "<"
+      when [:big, true]
+        str
+      when [:big, false]
+        str + ">"
+      else
+        str
+      end
     end
 
   end

data/lib/packed_struct/modifier.rb

@@ -0,0 +1,76 @@
+module PackedStruct
+  class Modifier
+
+    # Initializes the modifier.
+    def initialize(name)
+      @name = name
+      @type = nil
+      @value = nil
+    end
+
+    # The type of modifier it is.  Has three possible values:
+    # +:endian+, +:size+, and +:signedness+.
+    #
+    # @return [Symbol]
+    # @!parse
+    #   attr_reader :type
+    def type
+      compile! unless @compiled
+      @type
+    end
+
+    # The value of the modifier.  Has multiple possible values,
+    # including: +:little+, +:big+, +:short+, +:int+, +:long+,
+    # +:float+, +:null+, +:string+, +:unsigned+, +:signed+.
+    #
+    # @return [Symbol]
+    # @!parse
+    #   attr_reader :value
+    def value
+      compile! unless @compiled
+      @value
+    end
+
+    # Compiles the modifier into a usable format.  Stores the values
+    # it determines in +@type+ and +@value+.
+    #
+    # @raises [UnknownModifierError] if it can't detect the type of
+    #   modifier.
+    # @return [void]
+    def compile!
+      @compiled ||= begin
+        case @name
+        when :little_endian, :little, :lsb, :low
+          @type  = :endian
+          @value = :little
+        when :big_endian, :big, :msb, :high, :network
+          @type  = :endian
+          @value = :big
+        when :short, :int, :long, :float, :string
+          @type  = :type
+          @value = @name
+        when :unsigned, :signed
+          @type  = :signedness
+          @value = @name
+        when :null
+          @type  = :signedness
+          @value = :signed
+        when :spaced
+          @type  = :signedness
+          @value = :unsigned
+        when :double
+          @type  = :length
+          @value = :double
+        when :hex, :base64, :bit
+          @type  = :string_type
+          @value = @name
+        else
+          raise UnknownModifierError, "Unkown modifier: #{@name}"
+        end
+        true
+      end
+    end
+  end
+
+  class UnknownModifierError < StandardError; end
+end

data/lib/packed_struct/package.rb

@@ -9,7 +9,6 @@ module PackedStruct
     #
     # @return [Array<Directive>]
     def directives
-      @directives = @directives.select { |x| x.parent.nil? }
       @directives
     end
 
@@ -21,9 +20,11 @@ module PackedStruct
     # Turn the package into a string.  Uses the directives (calls
     # {Directive#to_s} on them), and joins the result.
     #
+    # @param data [Hash<Symbol, Object>] the data to pass to
+    #   {Directive#to_s}.
     # @return [String] the string ready for #pack.
-    def to_s
-      directives.map(&:to_s).join(' ')
+    def to_s(data = {})
+      directives.map { |x| x.to_s(data) }.join(' ')
     end
 
     alias_method :to_str, :to_s
@@ -31,7 +32,7 @@ module PackedStruct
     # Packs the given data into a string.  The keys of the data
     # correspond to the names of the directives.
     #
-    # @param [Hash<Symbol, Object>] the data.
+    # @param data [Hash<Symbol, Object>] the data.
     # @return [String] the packed data.
     def pack(data)
       values = []
@@ -44,23 +45,11 @@ module PackedStruct
       values = values.select { |x| mapped_directives.include?(x[0]) }
 
       values.sort! do |a, b|
-        o = mapped_directives.index(a[0]) <=> mapped_directives.index(b[0])
+        mapped_directives.index(a[0]) <=> mapped_directives.index(b[0])
       end
 
-      pack_with_array(values.map(&:last))
-    end
-
-    # Packs the directives into a string.  Uses an array.
-    # The parameters can either be an array, or a set of values.
-    #
-    # @return [String]
-    def pack_with_array(*array)
-      array.flatten!
-
-      directives.each_with_index { |e, i| e.value = array[i] }
-      out = array.pack(self.to_s)
-      directives.each { |x| x.value = nil }
-      out
+      ary = values.map(&:last)
+      ary.pack to_s(data)
     end
 
     # Unpacks the given string with the directives.  Returns a hash
@@ -73,18 +62,14 @@ module PackedStruct
       total = ""
       parts = {}
       directives.each_with_index do |directive, i|
-        total << directive.to_s
-        value = string.unpack(total)[i]
-        directive.value = value
-        parts[directive.name] = value
+        total << directive.to_s(parts)
+        parts[directive.name] = string.unpack(total)[i]
       end
 
-
-      directives.each { |x| x.value = nil }
-
       parts.delete(:null) {}
       parts
     end
+
     # Unpacks from a socket.
     #
     # @param sock [#read] the socket to unpack from.
@@ -95,15 +80,11 @@ module PackedStruct
       parts = {}
 
       directives.each_with_index do |directive, i|
-        total << directive.to_s
-        read << sock.read(directive.bytesize)
-        value = read.unpack(total)[i]
-        directive.value = value
-        parts[directive.name] = value
+        total << directive.to_s(parts)
+        read << sock.read(directive.bytesize parts)
+        parts[directive.name] = read.unpack(total)[i]
       end
 
-      directives.each { |x| x.value = nil }
-
       parts.delete(:null) {}
       parts
     end
@@ -126,6 +107,14 @@ module PackedStruct
       parts
     end
 
+    # Finalizes all of the directives.
+    #
+    # @return [void]
+    def finalize_directives!
+      @finalized = true
+      directives.reject!(&:empty?)
+      directives.map(&:finalize!)
+    end
 
     # Inspects the package.
     #
@@ -138,12 +127,11 @@ module PackedStruct
     #
     # @return [Directive] the new directive.
     def method_missing(method, *arguments, &block)
-      if @directives.map(&:name).include?(method) && arguments.length == 0
-        @directives.select { |x| x.name == method }.first
+      super if @finalized
+      if arguments.length == 1 && arguments.first.is_a?(Directive)
+        arguments.first.add_modifier Modifier.new(method)
       else
-        directive = Directive.new(method, *arguments)
-        @directives << directive
-        directive
+        (directives.push Directive.new(method)).last
       end
     end
 

data/lib/packed_struct/version.rb

@@ -1,5 +1,5 @@
 module PackedStruct
 
   # The current version of PackedStruct.
-  VERSION = "0.2.1".freeze
+  VERSION = "0.3.0".freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: packed_struct
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-26 00:00:00.000000000 Z
+date: 2013-06-27 00:00:00.000000000 Z
 dependencies: []
 description: ! '  Cleans up the string mess when packing items (in Array#pack) and
   unpacking items (in String#unpack).
@@ -23,6 +23,7 @@ files:
 - README.md
 - LICENSE
 - lib/packed_struct/version.rb
+- lib/packed_struct/modifier.rb
 - lib/packed_struct/package.rb
 - lib/packed_struct/directive.rb
 - lib/packed_struct.rb