schemata-staging 0.0.1.1

data/lib/schemata/common/error.rb

@@ -0,0 +1,12 @@
+module Schemata
+  class DecodeError < StandardError; end
+  class EncodeError < StandardError; end
+  class UpdateAttributeError < StandardError; end
+  class IncompatibleVersionError < DecodeError
+    def initialize(msg_version, component_version)
+      super("min message version #{msg_version} too high for component ver\
+sion #{component_version}")
+    end
+  end
+  class SchemaDefinitionError < StandardError; end
+end

data/lib/schemata/common/msgbase.rb

@@ -0,0 +1,260 @@
+require 'yajl'
+require 'schemata/common/error'
+
+module Schemata
+  module MessageBase
+
+    class ValidatingContainer
+      def initialize(data = {})
+        data ||= {}
+        @schema = self.class.const_get(:SCHEMA)
+        @contents = {}
+
+        data.each do |key, field_value|
+          field_schema = @schema.schemas[key]
+          next unless field_schema
+
+          begin
+            field_schema.validate(field_value)
+          rescue Membrane::SchemaValidationError => e
+            raise Schemata::UpdateAttributeError.new(e.message)
+          end
+
+          @contents[key] = Schemata::HashCopyHelpers.deep_copy(field_value)
+        end
+      end
+
+      def self.define(schema)
+        vc_klass = Class.new(self)
+        vc_klass.const_set(:SCHEMA, schema)
+        schema.schemas.each do |key, field_schema|
+          vc_klass.send(:define_method, key) do
+            if @contents[key]
+              return Schemata::HashCopyHelpers.deep_copy(@contents[key])
+            end
+            nil
+          end
+
+          vc_klass.send(:define_method, "#{key}=") do |field_value|
+            begin
+              field_schema.validate(field_value)
+            rescue Membrane::SchemaValidationError => e
+              raise Schemata::UpdateAttributeError.new(e.message)
+            end
+            @contents[key] = Schemata::HashCopyHelpers.deep_copy(field_value)
+            field_value
+          end
+        end
+        vc_klass
+      end
+
+      def contents
+        Schemata::HashCopyHelpers.deep_copy(@contents)
+      end
+
+      def empty?
+        @contents.empty?
+      end
+
+      def validate
+        @schema.validate(@contents)
+      end
+    end
+
+    def vc_klass
+      self.class.const_get(:VC_KLASS)
+    end
+
+    def aux_vc_klass
+      return self.class.const_get(:AUX_VC_KLASS) if self.class.aux_schema
+    end
+
+    def initialize(msg_data_hash = nil, aux_data_hash = nil)
+      @contents = vc_klass.new(msg_data_hash)
+      if self.class.aux_schema
+        @aux_contents = aux_vc_klass.new(aux_data_hash)
+      end
+    end
+
+    def encode
+      begin
+        validate_contents
+        validate_aux_data
+      rescue Membrane::SchemaValidationError => e
+        raise Schemata::EncodeError.new(e.message)
+      end
+
+      msg_type = message_type
+      curr_version = self.class.version
+      min_version = self.class::MIN_VERSION_ALLOWED
+
+      msg = { "V#{curr_version}" => contents }
+      curr_msg_obj = self
+      (min_version...curr_version).reverse_each do |v|
+        curr_msg_obj, old_fields =
+          curr_msg_obj.generate_old_fields
+         msg["V#{v}"] = old_fields
+      end
+      msg["min_version"] = min_version
+
+      if include_preschemata?
+        msg["V#{curr_version}"].each do |k, v|
+          msg[k] = v
+        end
+      end
+      Yajl::Encoder.encode(msg)
+    end
+
+    def include_preschemata?
+      self.class.const_get(:INCLUDE_PRESCHEMATA)
+    end
+
+    def validate_contents
+      @contents.validate
+    end
+
+    def validate_aux_data
+      @aux_contents.validate if self.class.aux_schema
+    end
+
+    def contents
+      @contents.contents
+    end
+
+    def aux_data
+      @aux_contents
+    end
+
+    def message_type
+      _, component, msg_type, version = self.class.name.split("::")
+      Schemata::const_get(component)::const_get(msg_type)
+    end
+
+    def self.included(klass)
+      klass.extend(Schemata::ClassMethods)
+      klass.extend(Dsl)
+    end
+  end
+
+  module ClassMethods
+    def mock
+      mock = {}
+      mock_values.keys.each do |k|
+        value = mock_values[k]
+        mock[k] = value.respond_to?("call") ? value.call : value
+      end
+      self.new(mock)
+    end
+
+    def schema
+      self::SCHEMA
+    end
+
+    def aux_schema
+      return self::AUX_SCHEMA if defined?(self::AUX_SCHEMA)
+    end
+
+    def mock_values
+      self::MOCK_VALUES
+    end
+
+    def version
+      _, component, msg_type, version = self.name.split("::")
+      version[1..-1].to_i
+    end
+
+    def previous_version
+      _, component, msg_type, version = self.name.split("::")
+      version = version[1..-1].to_i - 1
+      Schemata::const_get(component)::const_get(msg_type)::
+        const_get("V#{version}")
+    end
+  end
+
+  module Dsl
+    def define_schema(&blk)
+      schema = Membrane::SchemaParser.parse(&blk)
+      unless schema.kind_of? Membrane::Schema::Record
+        Schemata::SchemaDefinitionError.new("Schema must be a hash")
+      end
+      self::const_set(:SCHEMA, schema)
+    end
+
+    def define_aux_schema(&blk)
+      aux_schema = Membrane::SchemaParser.parse(&blk)
+      unless aux_schema.kind_of? Membrane::Schema::Record
+        Schemata::SchemaDefinitionError.new("Schema must be a hash")
+      end
+
+      self::const_set(:AUX_SCHEMA, aux_schema)
+    end
+
+    def define_min_version(min_version)
+      unless min_version.is_a? Integer
+        raise SchemaDefinitionError.new("Min version must be an integer")
+      end
+      const_set(:MIN_VERSION_ALLOWED, min_version)
+    end
+
+    def define_upvert(&blk)
+      eigenclass.send(:define_method, :upvert) do |old_data|
+        # No need to validate aux_data because upvert is only called during
+        # decode, when aux_data is irrelevant
+        begin
+          previous_version::SCHEMA.validate(old_data)
+        rescue Membrane::SchemaValidationError => e
+          raise Schemata::DecodeError.new(e.message)
+        end
+
+        blk.call(old_data)
+      end
+    end
+
+    def define_generate_old_fields(&blk)
+      self.send(:define_method, :generate_old_fields) do
+        if self.class.aux_schema && aux_data.empty?
+          raise Schemata::DecodeError.new("Necessary aux_data missing")
+        end
+        old_fields = blk.call(self)
+
+        msg_contents = contents
+        msg_contents.update(old_fields)
+        msg_obj = self.class.previous_version.new(msg_contents)
+
+        msg_obj.validate_contents
+        return msg_obj, old_fields
+      end
+    end
+
+    def define_mock_values(hash=nil, &blk)
+      if (hash && blk) ||  (!hash && !blk)
+        # value defined twice or not at all
+        raise SchemaDefinitionError.new("Mock values incorrectly defined")
+      end
+
+      hash = blk.call if blk
+
+      # Validate a sample of the mock values.
+      mock = {}
+      hash.each do |key, value|
+        mock[key] = value.respond_to?("call") ? value.call : value
+      end
+
+      begin
+        self.schema.validate(mock)
+        define_constant(:MOCK_VALUES, hash)
+      rescue Membrane::SchemaValidationError => e
+        raise SchemaDefinitionError.new("Sample mock values do not match schema: #{e}")
+      end
+    end
+
+    def define_constant(constant_name, constant_value)
+      self.const_set(constant_name, constant_value)
+    end
+
+    def include_preschemata
+      define_constant(:INCLUDE_PRESCHEMATA, true)
+    end
+
+  end
+end

data/lib/schemata/common/msgtypebase.rb

@@ -0,0 +1,122 @@
+require 'schemata/common/msgbase'
+require 'schemata/common/parsed_msg'
+
+module Schemata
+  module MessageTypeBase
+    def current_version
+      return @current_version if @current_version
+      @current_version = versions.max
+    end
+
+    def versions
+      str_versions = self.constants.select { |x| x =~ /^V[0-9]+$/ }
+      str_versions.map { |x| x[1..-1].to_i}
+    end
+
+    def current_class
+      self::const_get("V#{current_version}")
+    end
+
+    def decode(json_msg)
+      begin
+        parsed = Schemata::ParsedMessage.new(json_msg)
+      rescue Schemata::DecodeError => e
+        raise e unless versions.size == 1
+        return decode_raw_payload(json_msg)
+      end
+      message_version = parsed.version
+
+      curr_version = current_version
+      curr_class = current_class
+
+      if curr_version < parsed.min_version
+        # TODO - Perhaps we should add
+        #   || message_version < msg_type::Current::MIN_VERSION_ALLOWED
+        raise IncompatibleVersionError.new(
+          parsed.min_version,
+          curr_version)
+      end
+
+      msg_contents = parsed.contents["V#{message_version}"]
+      if curr_version <= message_version
+        (message_version - 1).downto(curr_version) do |v|
+          msg_contents.update(parsed.contents["V#{v}"])
+        end
+      else
+        (message_version + 1).upto(curr_version) do |v|
+          msg_contents = const_get("V#{v}")
+            .upvert(msg_contents)
+        end
+      end
+
+      begin
+        msg_obj = curr_class.new(msg_contents)
+        msg_obj.validate_contents
+        # We don't validate aux data in decode.
+        return msg_obj
+      rescue Schemata::UpdateAttributeError => e
+        raise Schemata::DecodeError.new(e.message)
+      rescue Membrane::SchemaValidationError => e
+        raise Schemata::DecodeError.new(e.message)
+      end
+    end
+
+    def self.extended(o)
+      o.extend Dsl
+    end
+
+    module Dsl
+      def version(v, &blk)
+        klass = Class.new
+        klass.instance_eval do
+          def eigenclass
+            class << self; self; end
+          end
+        end
+        klass.send(:include, Schemata::MessageBase)
+        klass.instance_eval(&blk)
+
+        if !defined? klass::INCLUDE_PRESCHEMATA
+          klass.const_set(:INCLUDE_PRESCHEMATA, false)
+        end
+
+        # Create the necessary ValidatingContainer subclasses (one for schema
+        # and, optionally, one for aux_schema
+        klass.instance_eval do
+          vc_klass = self::ValidatingContainer.define(self.schema)
+          self.const_set(:VC_KLASS, vc_klass)
+          if self.aux_schema
+            aux_vc_klass = self::ValidatingContainer.define(self.aux_schema)
+            self.const_set(:AUX_VC_KLASS, aux_vc_klass)
+          end
+        end
+
+        # Define attribute accessors for the message class
+        klass.schema.schemas.each do |key, field_schema|
+          klass.send(:define_method, key) do
+            @contents.send(key)
+          end
+          klass.send(:define_method, "#{key}=") do |field_value|
+            @contents.send("#{key}=", field_value)
+          end
+        end
+        self::const_set("V#{v}", klass)
+      end
+    end
+
+    private
+
+    def decode_raw_payload(json)
+      begin
+        msg_contents = Yajl::Parser.parse(json)
+        msg_obj = current_class.new(msg_contents)
+        msg_obj.validate_contents
+        return msg_obj
+      rescue Schemata::UpdateAttributeError,
+        Membrane::SchemaValidationError => e
+        raise Schemata::DecodeError.new(e.message)
+      end
+    end
+
+  end
+end

data/lib/schemata/common/parsed_msg.rb

@@ -0,0 +1,43 @@
+require 'schemata/helpers/hash_copy'
+require 'set'
+require 'yajl'
+
+module Schemata
+  class ParsedMessage
+
+    attr_reader :version, :min_version
+
+    def initialize(json)
+      @contents = Yajl::Parser.parse(json)
+
+      @min_version = @contents['min_version']
+      if !@min_version
+        raise DecodeError.new("Field 'min_version' abset from message")
+      end
+
+      versions = []
+      @contents.keys.each do |k|
+        next if k == 'min_version'
+        unless k =~ /^V[0-9]+$/
+          raise DecodeError.new("Invalid key: #{k}")
+        end
+        versions << k[1..-1].to_i
+      end
+
+      if versions.empty?
+        raise DecodeError.new("Message contains no versioned hashes")
+      end
+
+      if Set.new(versions.min..versions.max) != Set.new(versions)
+        raise DecodeError.new("There are versions missing between\
+ #{versions.min} and #{versions.max}")
+      end
+
+      @version = versions.max
+    end
+
+    def contents
+      Schemata::HashCopyHelpers.deep_copy(@contents)
+    end
+  end
+end

data/lib/schemata/helpers/hash_copy.rb

@@ -0,0 +1,28 @@
+module Schemata
+  module HashCopyHelpers
+    class CopyError < StandardError; end
+
+    def self.deep_copy(node)
+      case node
+      when String
+        return node.dup
+      when Numeric, TrueClass, FalseClass
+        return node
+      when Hash
+        copy = {}
+        # XXX NB: The 'to_s' below was included because some components use
+        # symbols as keys instead of strings. This fix is temporary; in the
+        # long term, we should change all components to use the same type for
+        # their keys
+        node.each { |k, v| copy[k.to_s] = deep_copy(v) }
+        return copy
+      when Array
+        return node.map { |v| deep_copy(v) }
+      when NilClass
+        return nil
+      else
+        raise CopyError.new("Unexpected class: #{node.class}")
+      end
+    end
+  end
+end