scon 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 61a64a294cb55566d8184fca83089010a4277ff5
+  data.tar.gz: 23577a76d5a336c369e21953a7e6052b30b787bc
+SHA512:
+  metadata.gz: f514339fbe3c8403dfa79dbe41f0ea7afdf379951bcea33ce5b9d3677ea1d1064f0172c0dbacb49b5cfb460fa49104c6909fd00c31bf5da956f85ae95d836753
+  data.tar.gz: 88e8161cce48e6ba7abda2ef6e8f7f0ebbc4c810694edd41216e3f08f598e2cc7c32d01d94e951594298a3ac3867dfceeb2cdf2b64f5e14a6d86e2be77dd9dc5

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in scon.gemspec
+gemspec

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/scon/constants.rb

@@ -0,0 +1,23 @@
+module SCON
+  module Constants
+    DATA = {
+      :byte => 0xA0,
+      :short => 0xA1,
+      :integer => 0xA2,
+      :long => 0xA3,
+      :float => 0xA4,
+      :double => 0xA5,
+
+      :nil => 0xC0,
+      :true => 0xC1,
+      :false => 0xC2,
+
+      :string => 0xD0,
+
+      :obj_start => 0xFA,
+      :obj_end => 0xFB,
+      :arr_start => 0xFC,
+      :arr_end => 0xFD
+    }
+  end
+end

data/lib/scon/generator.rb

@@ -0,0 +1,162 @@
+module SCON
+  class Generator
+
+    def generate! hashorarray
+      if hashorarray.is_a? Hash
+        return generate_type! hashorarray, :hash
+      elsif hashorarray.is_a? Array
+        return generate_type! hashorarray, :array
+      else
+        throw TypeError.new("Only Hash or Array types can be generated!")
+      end
+    end
+
+private
+    def generate_type! hash, type
+      @unique_keys = {}
+      @header_bytes = []
+      @body_bytes = []
+      @body_bytes << 0xF0 if type == :hash
+
+      if type == :hash
+        generate_keys hash
+      elsif type == :array
+        generate_keys_array hash
+      end
+      select_keys
+      encode_keys
+
+      encode_body hash
+
+      @body_bytes.flatten.pack("c*")
+    end
+
+    # Hash Methods
+    def generate_keys hash
+      hash.each do |key, value|
+        keys = key.to_s
+        @unique_keys[keys] ||= 0
+        @unique_keys[keys] += 1
+
+        if value.is_a? Hash
+          generate_keys value
+        elsif value.is_a? Array
+          generate_keys_array value
+        end
+      end
+    end
+
+    def generate_keys_array array
+      array.each do |v|
+        generate_keys v if v.is_a? Hash
+      end
+    end
+
+    def select_keys
+      selected = @unique_keys.select { |k, v| v >= 2 }
+      @unique_keys = selected.map { |k, v| k }
+    end
+
+    def encode_keys
+      if @unique_keys.length > 0
+        @header_bytes << 0xF1
+        @unique_keys.each do |key|
+          @header_bytes << Conversions.string_bytes(key)
+        end
+        @body_bytes.unshift(@header_bytes)
+        @header_bytes = nil
+      end
+    end
+
+    #General Methods
+    def encode_body object
+      if object.is_a? Hash
+        object.each do |k, v|
+          encode_value k, v, :hash
+        end
+      elsif object.is_a? Array
+        counter = 0
+        object.each_with_index do |v, i|
+          encode_value i, v, :array, counter
+          counter += 1
+        end
+      end
+    end
+
+    def encode_value key, value, parent_type, array_counter=0
+      instruct, serial = 0, nil
+      if value.is_a? Hash
+        @body_bytes << Constants::DATA[:obj_start]
+        encode_key key, parent_type, array_counter
+        value.each do |k, v|
+          encode_value k, v, :hash
+        end
+        @body_bytes << Constants::DATA[:obj_end]
+        return
+      elsif value.is_a? Array
+        @body_bytes << Constants::DATA[:arr_start]
+        encode_key key, parent_type, array_counter
+        counter = 0
+        value.each_with_index do |v, i|
+          encode_value i, v, :array, counter
+          counter += 1
+        end
+        @body_bytes << Constants::DATA[:arr_end]
+        return
+      elsif value.is_a? Fixnum
+        instruct, serial = auto_number(value)
+      elsif value.is_a? Float
+        instruct = Constants::DATA[:float]
+        serial = Conversions.float_bytes(value)
+      elsif value.is_a? String
+        bytes = Conversions.string_bytes(value)
+        instruct = bytes[0]
+        serial = bytes[1]
+      elsif value.is_a?(TrueClass)
+        instruct = Constants::DATA[:true]
+      elsif value.is_a?(FalseClass)
+        instruct = Constants::DATA[:false]
+      elsif value.nil?
+        instruct = Constants::DATA[:nil]
+      end
+
+      @body_bytes << instruct
+      encode_key key, parent_type, array_counter
+      @body_bytes << serial unless serial.nil?
+    end
+
+    def encode_key key, parent_type, array_counter
+      if parent_type == :hash
+        keys = key.to_s
+        encode_key_hash keys
+      end
+    end
+
+    def encode_key_hash keys
+      if @unique_keys.include? keys
+        index = @unique_keys.index(keys)
+        @body_bytes << auto_number(index)
+      else
+        @body_bytes << Conversions.string_bytes(keys)
+      end
+    end
+
+    def auto_number value
+      returnval = []
+      if value <= 0x99 && value >= 0      # Byte, no following data bytes
+        returnval[0] = value
+      elsif value <= ((2**16)/2-1) && value >= -(((2**16)/2-1))     # Short, following bytes
+        returnval[0] = Constants::DATA[:short]
+        returnval[1] = Conversions.short_bytes(value)
+      elsif value <= ((2**32)/2-1) && value >= -(((2**32)/2-1))     # Integer, following bytes
+        returnval[0] = Constants::DATA[:integer]
+        returnval[1] = Conversions.int_bytes(value)
+      else    # Long, following bytes
+        returnval[0] = Constants::DATA[:long]
+        returnval[1] = Conversions.long_bytes(value)
+      end
+      returnval
+    end
+
+  end
+end

data/lib/scon/parser.rb

@@ -0,0 +1,133 @@
+module SCON
+  class Parser
+
+    def parse! data
+      @data = data.bytes
+      if @data[0] == 0xF1  # Has Key Lookup
+        @keyassoc = []
+        @data.shift
+        while (temp = parse_inline_string(@data)) != false
+          @keyassoc << temp
+        end
+      end
+
+      if @data[0] == 0xF0    # Is a Hash
+        @data.shift
+        root = {}
+        hash_parse_entries root
+        return root
+      else                  # Is an Array
+        root = []
+        array_parse_entries root
+        return root
+      end
+    end
+
+private
+
+  def parse_inline_string data
+    if (data[0] > 0xD0) && (data[0] < (0xD0 + 32))
+      count = data.shift
+      return data.shift(count - 0xD0).pack("c*")
+    elsif data[0] == 0xD0
+      data.shift
+      str = []
+      while (tmp = data.shift) != 0x03
+        str << tmp
+      end
+      return str.pack("c*")
+    else
+      return false
+    end
+  end
+
+  def parse_string instruct
+    if (instruct > 0xD0) && (instruct < (0xD0 + 32))
+      return @data.shift(instruct - 0xD0).pack("c*")
+    elsif instruct == 0xD0
+      str = []
+      while (tmp = @data.shift) != 0x03
+        str << tmp
+      end
+      return str.pack("c*")
+    else
+      return false
+    end
+  end
+
+  def parse_value instruct
+    if instruct <= 0x99 && instruct >= 0      # Byte, no following data bytes
+      return instruct
+    elsif instruct == Constants::DATA[:byte]
+      return @data.shift[0]
+    elsif instruct == Constants::DATA[:short]
+      return @data.shift(2).pack("c*").unpack("s<")[0]
+    elsif instruct == Constants::DATA[:integer]
+      return @data.shift(4).pack("c*").unpack("i<")[0]
+    elsif instruct == Constants::DATA[:long]
+      return @data.shift(8).pack("c*").unpack("l<")[0]
+    elsif instruct == Constants::DATA[:float]
+      return @data.shift(4).pack("c*").unpack("e")[0]
+    elsif instruct == Constants::DATA[:double]
+      return @data.shift(8).pack("c*").unpack("E")[0]
+    elsif instruct == Constants::DATA[:nil]
+      return nil
+    elsif instruct == Constants::DATA[:true]
+      return true
+    elsif instruct == Constants::DATA[:false]
+      return false
+    elsif (tmp = parse_string(instruct)) != false
+      return tmp
+    elsif instruct == Constants::DATA[:obj_start]
+      root = {}
+      hash_parse_entries root
+      return root
+    elsif instruct == Constants::DATA[:arr_start]
+      root = []
+      array_parse_entries root
+      return root
+    end
+  end
+
+  def hash_parse_entries parent
+    closed = false
+    while !closed
+      data_type = @data.shift
+
+      if data_type == Constants::DATA[:obj_end]
+        closed = true
+        next
+      end
+
+      index_meta = @data.shift
+      index_val = parse_value index_meta
+      data_value = parse_value data_type
+
+      if index_val.is_a? Fixnum
+        parent[@keyassoc[index_val]] = data_value
+      elsif index_val.is_a? String
+        parent[index_val] = data_value
+      end
+
+      closed = true if @data.length == 0
+    end
+  end
+
+  def array_parse_entries parent
+    closed = false
+    while !closed
+      data_type = @data.shift
+
+      if data_type == Constants::DATA[:arr_end]
+        closed = true
+        next
+      end
+      data_value = parse_value data_type
+      parent << data_value
+
+      closed = true if @data.length == 0
+    end
+  end
+
+  end
+end

data/lib/scon/version.rb

@@ -0,0 +1,3 @@
+module SCON
+  VERSION = "0.0.1"
+end

data/lib/scon.rb

@@ -0,0 +1,47 @@
+require "scon/version"
+require "scon/constants"
+require "scon/generator"
+require "scon/parser"
+
+module SCON
+
+  def SCON.generate! hashorarray
+    SCON::Generator.new.generate! hashorarray
+  end
+
+  def SCON.parse! data
+    SCON::Parser.new.parse! data
+  end
+
+  class Conversions
+
+    def self.int_bytes int
+      [int].pack("i<").bytes
+    end
+
+    def self.short_bytes short
+      [short].pack("s<").bytes
+    end
+
+    def self.long_bytes long
+      [long].pack("l<").bytes
+    end
+
+    def self.string_bytes str
+      bytes = str.bytes
+      instr = 0xD0
+      if bytes.length < 32
+        instr += bytes.length
+      else
+        bytes << 0x03
+      end
+      [instr, bytes]
+    end
+
+    def self.float_bytes float
+      [float].pack("e").bytes
+    end
+
+  end
+
+end

data/scon.gemspec

@@ -0,0 +1,33 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'scon/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "scon"
+  spec.version       = SCON::VERSION
+  spec.authors       = ["JacisNonsense"]
+  spec.email         = ["jaci.brunning@gmail.com"]
+
+  spec.summary       = %q{Simple and Compressed Object Notation}
+  spec.description   = %q{Simple and Compressed Object Notation (SCON) serializes arrays
+    and objects into a binary format, all the while using as little space as possible by
+    reusing duplicate keys with a binary reference and clever type definitions.}
+  spec.homepage      = "http://www.github.com/JacisNonsense/scon"
+
+  # Prevent pushing this gem to RubyGems.org by setting 'allowed_push_host', or
+  # delete this section to allow pushing this gem to any host.
+  # if spec.respond_to?(:metadata)
+  #   spec.metadata['allowed_push_host'] = "TODO: Set to 'http://mygemserver.com'"
+  # else
+  #   raise "RubyGems 2.0 or newer is required to protect against public gem pushes."
+  # end
+
+  spec.bindir        = "bin"
+  spec.files = Dir.glob("lib/**/*") + ['Rakefile', 'scon.gemspec', 'Gemfile', 'Rakefile']
+  spec.executables   = []
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake"
+end

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification
+name: scon
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- JacisNonsense
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-09-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |-
+  Simple and Compressed Object Notation (SCON) serializes arrays
+      and objects into a binary format, all the while using as little space as possible by
+      reusing duplicate keys with a binary reference and clever type definitions.
+email:
+- jaci.brunning@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Rakefile
+- lib/scon.rb
+- lib/scon/constants.rb
+- lib/scon/generator.rb
+- lib/scon/parser.rb
+- lib/scon/version.rb
+- scon.gemspec
+homepage: http://www.github.com/JacisNonsense/scon
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Simple and Compressed Object Notation
+test_files: []