ruckus 0.5.4

data/lib/ruckus/dictionary.rb

@@ -0,0 +1,119 @@
+# === A collection of objects of which only one is active at any particular time
+
+module Ruckus
+  # A Dictionary is a collection of data objects of which only one is
+  # active at any particular time. This class extends and provies a simplified
+  # front-end for Choice.
+  #
+  class Dictionary < Choice
+    attr_accessor :dict, :selection
+
+    # Initializes a new Dictionary object.
+    # Parameters may be provided at initialisation to control the behaviour
+    # of an object. These params are:
+    #
+    #  dict       An indexable (generally hash or array) object with indexed
+    #             values mapped to the possible data objects. (see notes below)
+    #             Any indexable object using the [] method can be used,
+    #             provided that 'selection' returns a valid index. If a type
+    #             is to have parameters passed to it, then it should be
+    #             provided as [type, hash_params]
+    #
+    #  selection    An index into :dict which specifies the currently
+    #             active choice.
+    #
+    #  default    An optional parameter specifying the default class
+    #             to capture to.
+    #
+    # A selection may be any of the following:
+    #
+    #  - Immediate Value:
+    #    An immediate value to be used as the index. Fixnum
+    #
+    #  - Symbol:
+    #    A symbol which will be will be searched with 'find_tag' from the
+    #    root of the parent structure. The value of the tagged element is used
+    #    as the index.
+    #     - By default a type symbol will be converted to an immediate name and
+    #     pulled from the Ruckus namespace.
+    #     - To specify another namespace, use the :dict_from parameter as in
+    #      ":dict_from => Name::Space". A :dict_from namespace can be
+    #      set globally or overidden as a per choice parameter.
+    #
+    #  - Proc/Lambda:
+    #    The lambda or proc is called and passed the following parameters:
+    #
+    #        'buf'  - The capture buffer
+    #        'this' - A reference to the current choice structure.
+    #
+    #    The lambda must return either of the following
+    #
+    #        An immediate value for the index to select
+    #
+    #        An array pair consisting of the immediate value and sub-string
+    #        buffer for the selection.
+    #
+    #        NOTE: The latter form allows the proc to perform its own internal
+    #        'captures'. The proc is expected to remove (slice!) any contents
+    #        from the original buffer for whatever extractions are made with
+    #        'capture'.
+    #
+    def initialize(opts={})
+      @dict = (opts[:dict] || [])
+      @selection = (opts[:selection] || nil)
+      @dict_from = (opts[:dict_from] || Ruckus)
+      @default = opts[:default]
+
+      # This lambda is passed to the 'choice' superclass to provide
+      # all the dictionary functionality.
+      block = lambda do |buf, this|
+        lambuf = nil
+        case @selection
+        when Symbol
+          sel = (x=this.root.find_tag(@selection) and x.value)
+        when Proc
+          sel, lambuf = @selection.call(buf,this)
+        else
+          sel = @selection
+        end
+
+        if (k = @dict[sel]) or (k = @default)
+          ksym, *args = k
+          return buf unless ksym
+
+          unless args[-1].kind_of?(Hash) and nsp=args[-1][:dict_from]
+            nsp = @dict_from
+          end
+
+          klass = if (ksym.kind_of? Class or ksym.kind_of? Module)
+                    ksym
+                  else
+                    ksym.to_s.const_lookup(nsp) or return(buf)
+                  end
+
+          choice = klass.new(*args)
+          choice.parent = this.value.parent
+          this.value = choice
+
+          if not lambuf.nil?
+            return buf if x=this.value.capture(lambuf) and x.empty?
+          else
+            this.value.capture(buf)
+          end
+        end
+      end
+
+      super( opts.merge(:block => block) )
+    end
+
+  end # class Dictionary
+
+  class Structure
+    # Convenience alias for 'dictionary'. First arg is "name", all others
+    # are passed directly into 'new'
+    def self.dict(*args)
+      with_args(*args) {|name, opts| dictionary opts.merge(:name => name)}
+    end
+  end
+
+end # module Ruckus

data/lib/ruckus/enum.rb

@@ -0,0 +1,39 @@
+
+module Ruckus
+  class Enum < Number
+    attr_accessor :enums
+
+    def initialize(opts={})
+      super(opts)
+      @enums ||= []
+      raise "enums must be Enumerable" unless @enums.kind_of? Enumerable
+    end
+
+    def to_human(indent="")
+      "#{indent}#{@name} = #{@value}(#{@value.to_hex}) [ #{ ((n=lookup)? n : "???").to_s } ]"
+    end
+
+    def lookup
+      if (o=@enums[@value]).kind_of?(Hash) then o[:name] else o end
+    end
+  end
+
+  class Structure
+    def self.enum16le(*args)
+      with_args(*args) {|name, opts| enum name, opts.merge(:width => 16, :endian => :little)}
+    end
+
+    def self.enum32le(*args)
+      with_args(*args) {|name, opts| enum name, opts.merge(:width => 32, :endian => :little)}
+    end
+
+    def self.enum16be(*args)
+      with_args(*args) {|name, opts| enum name, opts.merge(:width => 16, :endian => :big)}
+    end
+
+    def self.enum32be(*args)
+      with_args(*args) {|name, opts| enum name, opts.merge(:width => 32, :endian => :big)}
+    end
+  end
+end
+

data/lib/ruckus/extensions/array.rb

@@ -0,0 +1,33 @@
+class Array
+    module ArrayExtensions
+        # Assume an array of key, value tuples, and convert to Hash
+        def to_hash
+            r = {}
+            each {|it| r[it[0]] = it[1]}
+            return r
+        end
+
+        def kind_of_these? y
+            inject(false) {|acc, klass| acc || y.kind_of?(klass)}
+        end
+
+        #return first hash-like element with key k
+        def kassoc(k)
+            # XXX not used
+            each { |h| return h if h.try(:has_key?, k) }
+            return nil
+        end
+
+        #return first hash-like element with value v
+        def vassoc(v)
+            # XXX not used
+            each { |h| return h if h.try(:has_value?, v) }
+            return nil
+        end
+
+        def extract_options!
+            last.is_a?(::Hash) ? pop : {}
+        end
+    end
+    include ArrayExtensions
+end

data/lib/ruckus/extensions/class.rb

@@ -0,0 +1,168 @@
+class Class
+    module ClassExtensions
+        # Also crazy that this isn't in the library
+        def inherits_from?(klass)
+            return true if self == klass
+            return true if self.superclass == klass
+            return false if self.superclass == Object
+
+            rec = lambda do |x|
+                if x == Object
+                    false
+                elsif x == klass
+                    true
+                else
+                    rec.call(x.superclass)
+                end
+            end
+
+            rec.call(self)
+        end
+
+        def alias_cmethod(to, from)
+            # XXX not used
+            (class << self;self;end).class_eval {
+                define_method to do |*args|
+                    send(from, *args)
+                end
+            }
+        end
+
+
+        # Allows attributes to be shared within an inheritance hierarchy, but where each descendant gets a copy of
+        # their parents' attributes, instead of just a pointer to the same. This means that the child can add elements
+        # to, for example, an array without those additions being shared with either their parent, siblings, or
+        # children, which is unlike the regular class-level attributes that are shared across the entire hierarchy.
+        def class_inheritable_reader(*syms)
+            syms.each do |sym|
+                next if sym.is_a?(Hash)
+                class_eval <<-EOS
+def self.#{sym}
+    read_inheritable_attribute(:#{sym})
+end
+
+def #{sym}
+    self.class.#{sym}
+end
+EOS
+             end
+       end
+
+        def class_inheritable_writer(*syms)
+            options = syms.extract_options!
+            syms.each do |sym|
+                class_eval <<-EOS
+        def self.#{sym}=(obj)
+          write_inheritable_attribute(:#{sym}, obj)
+        end
+
+        #{"
+        def #{sym}=(obj)
+          self.class.#{sym} = obj
+        end
+        " unless options[:instance_writer] == false }
+       EOS
+          end
+       end
+
+       def class_inheritable_array_writer(*syms)
+           options = syms.extract_options!
+           syms.each do |sym|
+               class_eval <<-EOS
+        def self.#{sym}=(obj)
+          write_inheritable_array(:#{sym}, obj)
+        end
+
+        #{"
+        def #{sym}=(obj)
+          self.class.#{sym} = obj
+        end
+        " unless options[:instance_writer] == false }
+      EOS
+          end
+      end
+
+        def class_inheritable_hash_writer(*syms)
+            options = syms.extract_options!
+            syms.each do |sym|
+                class_eval <<-EOS
+        def self.#{sym}=(obj)
+          write_inheritable_hash(:#{sym}, obj)
+        end
+
+        #{"
+        def #{sym}=(obj)
+          self.class.#{sym} = obj
+        end
+        " unless options[:instance_writer] == false }
+      EOS
+            end
+        end
+
+        def class_inheritable_accessor(*syms)
+            class_inheritable_reader(*syms)
+            class_inheritable_writer(*syms)
+        end
+
+        def class_inheritable_array(*syms)
+            class_inheritable_reader(*syms)
+            class_inheritable_array_writer(*syms)
+        end
+
+        def class_inheritable_hash(*syms)
+            class_inheritable_reader(*syms)
+            class_inheritable_hash_writer(*syms)
+        end
+
+        def inheritable_attributes
+            @inheritable_attributes ||= EMPTY_INHERITABLE_ATTRIBUTES
+        end
+
+        def write_inheritable_attribute(key, value)
+            if inheritable_attributes.equal?(EMPTY_INHERITABLE_ATTRIBUTES)
+                @inheritable_attributes = {}
+            end
+            inheritable_attributes[key] = value
+        end
+
+        def write_inheritable_array(key, elements)
+            write_inheritable_attribute(key, []) if read_inheritable_attribute(key).nil?
+            write_inheritable_attribute(key, read_inheritable_attribute(key) + elements)
+        end
+
+        def write_inheritable_hash(key, hash)
+            write_inheritable_attribute(key, {}) if read_inheritable_attribute(key).nil?
+            write_inheritable_attribute(key, read_inheritable_attribute(key).merge(hash))
+        end
+
+        def read_inheritable_attribute(key)
+            inheritable_attributes[key]
+        end
+
+        def reset_inheritable_attributes
+            @inheritable_attributes = EMPTY_INHERITABLE_ATTRIBUTES
+        end
+private
+
+        # Prevent this constant from being created multiple times
+        EMPTY_INHERITABLE_ATTRIBUTES = {}.freeze unless const_defined?(:EMPTY_INHERITABLE_ATTRIBUTES)
+
+        def inherited_with_inheritable_attributes(child)
+            inherited_without_inheritable_attributes(child) if respond_to?(:inherited_without_inheritable_attributes)
+
+            if inheritable_attributes.equal?(EMPTY_INHERITABLE_ATTRIBUTES)
+                new_inheritable_attributes = EMPTY_INHERITABLE_ATTRIBUTES
+            else
+                new_inheritable_attributes = inheritable_attributes.inject({}) do |memo, (key, value)|
+                    memo.update(key => value.duplicable? ? value.dup : value)
+                end
+            end
+
+            child.instance_variable_set('@inheritable_attributes', new_inheritable_attributes)
+        end
+    end
+
+    include ClassExtensions
+    alias inherited_without_inheritable_attributes inherited
+    alias inherited inherited_with_inheritable_attributes
+end

data/lib/ruckus/extensions/duplicable.rb

@@ -0,0 +1,37 @@
+class Object
+    # Can you safely .dup this object?
+    # False for nil, false, true, symbols, and numbers; true otherwise.
+    def duplicable?
+        true
+    end
+end
+
+class NilClass #:nodoc:
+    def duplicable?
+        false
+    end
+end
+
+class FalseClass #:nodoc:
+    def duplicable?
+        false
+    end
+end
+
+class TrueClass #:nodoc:
+    def duplicable?
+        false
+    end
+end
+
+class Symbol #:nodoc:
+    def duplicable?
+        false
+    end
+end
+
+class Numeric #:nodoc:
+    def duplicable?
+        false
+    end
+end

data/lib/ruckus/extensions/file.rb

@@ -0,0 +1,24 @@
+class File
+    module FileExtensions
+        module ClassMethods
+            def mkfifo(name, mode="666", open_mode="r")
+                # XXX not used
+                if File.exists? name and File.pipe? name # Leftover from before
+                    File.delete name
+                end
+
+                # apalling, but ruby/dl has x-p problems
+                if ! File.exists? name
+                    `mkfifo -m #{ mode } #{ name }`
+                end
+
+                return File.open(name, open_mode)
+            end
+        end
+
+        def self.included(klass)
+            klass.extend(ClassMethods)
+        end
+    end
+    include FileExtensions
+end

data/lib/ruckus/extensions/fixnum.rb

@@ -0,0 +1,26 @@
+class Fixnum
+    module FixnumExtensions
+        # Ridiculous that this isn't in the library.
+        def printable?; self >= 0x20 and self <= 0x7e; end
+
+        # Like Numeric#Step, but yields the length of each span along with
+        # the offset. Useful for stepping through data in increments:
+        # 0.stepwith(buffer.size, 4096) {|off,len| pp buffer[off,len]}
+        # The "len" parameter accounts for the inevitable short final block.
+        def stepwith(limit, stepv, &block)
+            # XXX not used
+            step(limit, stepv) do |i|
+                remt = limit - i
+                yield i, remt.cap(stepv)
+            end
+        end
+
+        # you can't clone a fixnum? Why?
+        def clone; self; end
+
+        def upper?; self >= 0x41 and self <= 0x5a; end
+        def lower?; self >= 0x61 and self <= 0x7a; end
+    end
+    include FixnumExtensions
+end
+