craftbook-nbt 1.0.0

data/lib/craftbook/nbt/int_array_tag.rb

@@ -0,0 +1,38 @@
+
+module CraftBook
+
+  module NBT
+    ##
+    # Represents a contiguous collection of signed 32-bit integers in the range of `-2147483648` to `2147483647`
+    # inclusive.
+    class IntArrayTag < EnumerableTag
+
+      ##
+      # Creates a new instance of the {IntArrayTag} class.
+      #
+      # @param name [String,NilClass] The name of the tag, or `nil` when unnamed.
+      # @param values [Array<Numeric>] Zero or more values to add during initialization.
+      def initialize(name, *values)
+        super(TYPE_INT_ARRAY, name, *values)
+      end
+
+      ##
+      # @return [Hash{Symbol => Object}] the hash-representation of this object.
+      def to_h
+        { name: @name, type: @type, values: @values }
+      end
+
+      ##
+      # @return [String] the NBT tag as a formatted and human-readable string.
+      def to_s
+        "TAG_Int_Array(#{@name ? "\"#{@name}\"" : 'None'}): #{size} #{size == 1 ? 'item' : 'items'}"
+      end
+
+      ##
+      # @return [String] the NBT tag as an SNBT string.
+      def stringify
+        "#{snbt_prefix}[I;#{to_a.join(',')}]"
+      end
+    end
+  end
+end

data/lib/craftbook/nbt/int_tag.rb

@@ -0,0 +1,49 @@
+
+module CraftBook
+
+  module NBT
+
+    ##
+    # Represents a signed 32-bit integer in the range of `-2147483648` to `2147483647` inclusive.
+    class IntTag < ValueTag
+
+      ##
+      # The minimum permissible value for this type.
+      MIN = -0x80000000
+
+      ##
+      # The maximum permissible value for this type.
+      MAX =  0x7FFFFFFF
+
+      ##
+      # @!attribute [rw] value
+      #   @return [Numeric] the value of the tag.
+
+      ##
+      # Creates a new instance of the {IntTag} class.
+      #
+      # @param name [String,NilClass] The name of the tag, or `nil` when unnamed.
+      # @param value [Numeric] The value of the tag.
+      def initialize(name, value = 0)
+        super(TYPE_INT, name, value)
+      end
+
+      def value=(value)
+        validate(value, MIN, MAX)
+        @value = Integer(value)
+      end
+
+      ##
+      # @return [String] the NBT tag as a formatted and human-readable string.
+      def to_s
+        "TAG_Int(#{@name ? "\"#{@name}\"" : 'None'}): #{@value}"
+      end
+
+      ##
+      # @return [String] the NBT tag as an SNBT string.
+      def stringify
+        "#{snbt_prefix}#{@value}"
+      end
+    end
+  end
+end

data/lib/craftbook/nbt/list_tag.rb

@@ -0,0 +1,69 @@
+
+module CraftBook
+
+  module NBT
+
+    ##
+    # Represents a collection of **unnamed** tags of the same type.
+    class ListTag < ContainerTag
+
+      ##
+      # @return [Integer] One of the `Tag::TYPE_*` constants indicating the primitive type of the child tags.
+      attr_reader :child_type
+
+      ##
+      # Creates a new instance of the {ListTag} class.
+      #
+      # @param name [String,NilClass] The name of the tag, or `nil` when unnamed.
+      # @param child_type [Integer] One of the `Tag::TYPE_*` constants indicating the primitive type of the child tags.
+      # @param values [Array<Tag>] Zero or more values to add during initialization.
+      def initialize(name, child_type, *values)
+        super(TYPE_LIST, name, *values)
+        @child_type = Integer(child_type)
+      end
+
+      ##
+      # @return [String] the NBT tag as a formatted and human-readable string.
+      def to_s
+        "TAG_List(#{@name ? "\"#{@name}\"" : 'None'}): #{size} #{size == 1 ? 'child' : 'children'}"
+      end
+
+      ##
+      # @return [String] the NBT tag as an SNBT string.
+      def stringify
+        "#{snbt_prefix}[#{map(&:stringify).join(',')}]"
+      end
+
+      ##
+      # @return [Hash{Symbol => Object}] the hash-representation of this object.
+      def to_h
+        children = @values.map do |obj|
+          child = obj.to_h
+          child.delete(:name)
+          child.delete(:type)
+          child
+        end
+        { name: @name, type: @type, child_type: @child_type, values: children }
+      end
+
+      protected
+
+      def parse_hash(hash)
+        @values = []
+        values = hash[:values]
+        child_type = hash[:child_type]
+        raise(ParseError, "invalid array") unless values.is_a?(Array)
+        raise(ParseError, "invalid child type") unless !child_type.nil? & child_type.between?(TYPE_END, TYPE_LONG_ARRAY)
+
+        klass = Tag.class_from_type(child_type)
+        values.each do |value|
+          child = klass.allocate
+          child.instance_variable_set(:@name, nil)
+          child.instance_variable_set(:@type, child_type)
+          child.send(:parse_hash, value)
+          push(child)
+        end
+      end
+    end
+  end
+end

data/lib/craftbook/nbt/long_array_tag.rb

@@ -0,0 +1,37 @@
+
+module CraftBook
+  module NBT
+    ##
+    # cRepresents a contiguous collection of signed 64-bit integers in the range of `-9223372036854775808`
+    # and `9223372036854775807` inclusive.
+    class LongArrayTag < EnumerableTag
+
+      ##
+      # Creates a new instance of the {LongArrayTag} class.
+      #
+      # @param name [String,NilClass] The name of the tag, or `nil` when unnamed.
+      # @param values [Array<Numeric>] Zero or more values to add during initialization.
+      def initialize(name, *values)
+        super(TYPE_LONG_ARRAY, name, *values)
+      end
+
+      ##
+      # @return [Hash{Symbol => Object}] the hash-representation of this object.
+      def to_h
+        { name: @name, type: @type, values: @values }
+      end
+
+      ##
+      # @return [String] the NBT tag as a formatted and human-readable string.
+      def to_s
+        "TAG_Long_Array(#{@name ? "\"#{@name}\"" : 'None'}): #{size} #{size == 1 ? 'item' : 'items'}"
+      end
+
+      ##
+      # @return [String] the NBT tag as an SNBT string.
+      def stringify
+        "#{snbt_prefix}[L;#{to_a.join(',')}]"
+      end
+    end
+  end
+end

data/lib/craftbook/nbt/long_tag.rb

@@ -0,0 +1,50 @@
+
+module CraftBook
+
+  module NBT
+
+    ##
+    # Represents a signed 64-bit integer in the range of `-9223372036854775808` and `9223372036854775807` inclusive.
+    class LongTag < ValueTag
+
+      ##
+      # The minimum permissible value for this type.
+      MIN = -0x8000000000000000
+
+      ##
+      # The maximum permissible value for this type.
+      MAX =  0x7FFFFFFFFFFFFFFF
+
+      ##
+      # @!attribute [rw] value
+      #   @return [Numeric] the value of the tag.
+
+
+      ##
+      # Creates a new instance of the {LongTag} class.
+      #
+      # @param name [String,NilClass] The name of the tag, or `nil` when unnamed.
+      # @param value [Numeric] The value of the tag.
+      def initialize(name, value = 0)
+        super(TYPE_LONG, name, value)
+      end
+
+      def value=(value)
+        validate(value, MIN, MAX)
+        @value = Integer(value)
+      end
+
+      ##
+      # @return [String] the NBT tag as a formatted and human-readable string.
+      def to_s
+        "TAG_Long(#{@name ? "\"#{@name}\"" : 'None'}): #{@value}"
+      end
+
+      ##
+      # @return [String] the NBT tag as an SNBT string.
+      def stringify
+        "#{snbt_prefix}#{@value}L"
+      end
+    end
+  end
+end

data/lib/craftbook/nbt/short_tag.rb

@@ -0,0 +1,48 @@
+
+module CraftBook
+  module NBT
+
+    ##
+    # Represents a signed 16-bit integer in the range of `-32768` to `32767` inclusive.
+    class ShortTag < ValueTag
+
+      ##
+      # The minimum permissible value for this type.
+      MIN = -0x8000
+
+      ##
+      # The maximum permissible value for this type.
+      MAX =  0x7FFF
+
+      ##
+      # @!attribute [rw] value
+      #   @return [Numeric] the value of the tag.
+
+      ##
+      # Creates a new instance of the {ShortTag} class.
+      #
+      # @param name [String,NilClass] The name of the tag, or `nil` when unnamed.
+      # @param value [Numeric] The value of the tag.
+      def initialize(name, value = 0)
+        super(TYPE_SHORT, name, value)
+      end
+
+      def value=(value)
+        validate(value, MIN, MAX)
+        @value = Integer(value)
+      end
+
+      ##
+      # @return [String] the NBT tag as a formatted and human-readable string.
+      def to_s
+        "TAG_Short(#{@name ? "\"#{@name}\"" : 'None'}): #{@value}"
+      end
+
+      ##
+      # @return [String] the NBT tag as an SNBT string.
+      def stringify
+        "#{snbt_prefix}#{@value}S"
+      end
+    end
+  end
+end

data/lib/craftbook/nbt/snbt/lexer.rb

@@ -0,0 +1,161 @@
+#--
+# DO NOT MODIFY!!!!
+# This file is automatically generated by rex 1.0.7
+# from lexical definition file "lib/craftbook/nbt/snbt/snbt.rex".
+#++
+
+require 'racc/parser'
+module CraftBook
+module NBT
+class Tokenizer < Racc::Parser
+      require 'strscan'
+
+      class ScanError < StandardError ; end
+
+      attr_reader   :lineno
+      attr_reader   :filename
+      attr_accessor :state
+
+      def scan_setup(str)
+        @ss = StringScanner.new(str)
+        @lineno =  1
+        @state  = nil
+      end
+
+      def action
+        yield
+      end
+
+      def scan_str(str)
+        scan_setup(str)
+        do_parse
+      end
+      alias :scan :scan_str
+
+      def load_file( filename )
+        @filename = filename
+        File.open(filename, "r") do |f|
+          scan_setup(f.read)
+        end
+      end
+
+      def scan_file( filename )
+        load_file(filename)
+        do_parse
+      end
+
+
+        def next_token
+          return if @ss.eos?
+
+          # skips empty actions
+          until token = _next_token or @ss.eos?; end
+          token
+        end
+
+        def _next_token
+          text = @ss.peek(1)
+          @lineno  +=  1  if text == "\n"
+          token = case @state
+            when nil
+          case
+                  when (text = @ss.scan(/\{[\s]*/))
+                     action { [:COMPOUND_BEGIN] }
+
+                  when (text = @ss.scan(/[\s]*\}/))
+                     action { [:COMPOUND_END] }
+
+                  when (text = @ss.scan(/".+?"(?=:)/))
+                     action { [:IDENTIFIER, text.gsub!(/\A"|"\Z/, '') ] }
+
+                  when (text = @ss.scan(/'.+?'(?=:)/))
+                     action { [:IDENTIFIER, text.gsub!(/\A'|'\Z/, '') ] }
+
+                  when (text = @ss.scan(/[A-Za-z0-9_-]+?(?=:)/))
+                     action { [:IDENTIFIER, text] }
+
+                  when (text = @ss.scan(/".*?"/))
+                     action { [:STRING, text.gsub!(/\A"|"\Z/, '') ] }
+
+                  when (text = @ss.scan(/'.*?'/))
+                     action { [:STRING, text.gsub!(/\A'|'\Z/, '') ] }
+
+                  when (text = @ss.scan(/[\s]*:[\s]*/))
+                     action { [:SEPARATOR, text] }
+
+                  when (text = @ss.scan(/[\s]*,[\s]*/))
+                     action { [:COMMA, text] }
+
+                  when (text = @ss.scan(/\[B;[\s]*?/))
+                     action { [:BYTE_ARRAY, text] }
+
+                  when (text = @ss.scan(/\[I;[\s]*?/))
+                     action { [:INT_ARRAY, text]  }
+
+                  when (text = @ss.scan(/\[L;[\s]*?/))
+                     action { [:LONG_ARRAY, text] }
+
+                  when (text = @ss.scan(/\[[\s]*?/))
+                     action { [:LIST_ARRAY, text] }
+
+                  when (text = @ss.scan(/[\s]*\]/))
+                     action { [:END_ARRAY, text]  }
+
+                  when (text = @ss.scan(/-?[0-9]*\.[0-9]+[Ff]/))
+                     action { [:FLOAT,  text.chop.to_f         ] }
+
+                  when (text = @ss.scan(/-?[0-9]*\.[0-9]+[Dd]?/))
+                     action { [:DOUBLE, text.tr('Dd', '').to_f ] }
+
+                  when (text = @ss.scan(/-?([0-9]+)[Bb]/))
+                     action { [:BYTE,   text.chop.to_i         ] }
+
+                  when (text = @ss.scan(/-?([0-9]+)[Ss]/))
+                     action { [:SHORT,  text.chop.to_i         ] }
+
+                  when (text = @ss.scan(/-?([0-9]+)[Ll]/))
+                     action { [:LONG,   text.chop.to_i         ] }
+
+                  when (text = @ss.scan(/-?([0-9]+)/))
+                     action { [:INT,    text.to_i              ] }
+
+                  when (text = @ss.scan(/[\s]+/))
+                     action { [:WHITESPACE, text] }
+
+                  when (text = @ss.scan(/[\S]+/))
+                     action { [:STRING, text] }
+
+                  when (text = @ss.scan(/./))
+                     action { [:CHAR, text] }
+
+          
+          else
+            text = @ss.string[@ss.pos .. -1]
+            raise  ScanError, "can not match: '" + text + "'"
+          end  # if
+
+        else
+          raise  ScanError, "undefined state: '" + state.to_s + "'"
+        end  # case state
+          token
+        end  # def _next_token
+
+  Token = Struct.new(:type, :value)
+  def tokenize(code)
+    scan_setup(code)
+    if block_given?
+      while token = next_token
+        yield Token.new(*token)
+      end
+      return self
+    end
+    tokens = []
+    while token = next_token
+      tokens << Token.new(*token)
+    end
+    tokens
+  end
+end # class
+
+end
+end