icss-activesupport-4 0.4.0

data/lib/icss/type/structured_schema.rb

@@ -0,0 +1,288 @@
+module Icss
+  module Meta
+
+    class NamedSchema
+      include Icss::Meta::RecordModel
+      include Icss::ReceiverModel::ActsAsHash
+      include Gorillib::Hashlike
+      field     :fullname, String,  :required => true
+      field     :is_core,  Boolean, :default => false
+      attr_accessor :is_core
+
+      rcvr_alias :name, :fullname
+      #
+      class_attribute :klass_metatypes   ; self.klass_metatypes   = []
+      class_attribute :parent_metamodels ; self.parent_metamodels = []
+
+      after_receive(:verify_name) do |hsh|
+        warn "** Missing name for #{self}" unless self.fullname.present?
+      end
+
+      after_receive(:register) do |hsh|
+        begin
+          Icss::Meta::Type.register(self.model_klass)
+        rescue
+          # If all after_receivers haven't been called, model_klass may error.
+          # Adding another after_receiver here, adds it to the end of the list
+          self.class.after_receive(:register_again) do
+            Icss::Meta::Type.register(self.model_klass)
+          end
+        end
+      end
+
+      def is_core?
+        !!is_core
+      end
+
+      def attrs_to_inscribe
+        self.class.field_names
+      end
+
+      def model_klass
+        return @model_klass if @model_klass
+        @model_klass = Icss::Meta::NamedType.get_model_klass(fullname, parent_klass||Object)
+        model_type = @model_klass.singleton_class
+        # inscribe attributes
+        attrs_to_inscribe.each do |attr|
+          val = self.send(attr)
+          model_type.class_eval{ define_method(attr){ val } }
+        end
+        schema_writer = self
+        model_type.class_eval{ define_method(:_schema){ schema_writer } }
+        # module inclusions
+        parent_metamodels.each do |parent_metamodel|
+          @model_klass.class_eval{ include parent_metamodel }
+        end
+        klass_metatypes.each{|mt| @model_klass.extend(mt) }
+        @model_klass.metamodel if @model_klass.respond_to?(:metamodel)
+        @model_klass
+      end
+      #
+      def self.receive(schema)
+        super(schema).model_klass
+      end
+      def to_hash
+        hsh = super
+        hsh[:type] = type
+        hsh[:name] = hsh.delete(:fullname)
+        hsh.delete(:is_core)
+        hsh
+      end
+    end
+
+    class StructuredSchema < NamedSchema
+      class_attribute :parent_klass
+      self.klass_metatypes = [::Icss::Meta::NamedType]
+    end
+
+    # An array of objects with a specified type.
+    module ArrayType
+      def receive(raw)
+        return nil if raw.nil? || (raw == "")
+        self.new( raw.map{|raw_item| raw_item.is_a?(items) ? raw_item : items.receive(raw_item) } )
+      end
+      def to_schema() _schema.to_hash end
+    end
+    module ArrayModel
+      def to_wire(options={})
+        map{|item| item.respond_to?(:to_wire) ? item.to_wire(options) : item }
+      end
+    end
+
+    # A hash of objects with a specified type.
+    module HashType
+      def receive(raw)
+        return nil if raw.nil? || (raw == "")
+        obj = self.new
+        raw.each{|rk,rv| obj[rk] = (rv.is_a?(values) ? rv : values.receive(rv)) }
+        obj
+      end
+      def to_schema() _schema.to_hash end
+    end
+
+    # A symbol from a pre-chosen set
+    module EnumType
+      def receive(raw)
+        obj = super(raw) or return
+        unless self.symbols.include?(obj) then raise ArgumentError, "Cannot receive #{raw}: must be one of #{symbols[0..2].join(',')}#{symbols.length > 3 ? ",..." : ""}" ; end
+        obj
+      end
+      def to_schema() _schema.to_hash end
+    end
+
+    # A Fixed-length buffer. The class size specifies the number of bytes per value (required).
+    module FixedType
+      # Error thrown when a FixedType is given too few/many bytes
+      class FixedValueWrongSizeError < ArgumentError ; end
+      # accept like a string but enforce (violently) the length constraint
+      def receive(raw)
+        obj = super(raw) ; return nil if obj.blank?
+        unless obj.bytesize == self.size then raise FixedValueWrongSizeError.new("Wrong size for a fixed-length type #{self.fullname}: got #{obj.bytesize}, not #{self.size}") ; end
+        obj
+      end
+      def to_schema() _schema.to_hash end
+    end
+
+    # -------------------------------------------------------------------------
+    #
+    # Container Types (array, map and union)
+    #
+
+    #
+    # ArraySchema describes an Array type (as opposed to ArrayType, which
+    # implements it)
+    #
+    # Arrays use the type name "array" and support a single attribute:
+    #
+    # * items: the schema of the array's items.
+    #
+    # @example, an array of strings is declared with:
+    #
+    #     {"type": "array", "items": "string"}
+    #
+    class ArraySchema < ::Icss::Meta::StructuredSchema
+      self.parent_klass       = Array
+      self.klass_metatypes   += [::Icss::Meta::ArrayType]
+      self.parent_metamodels += [::Icss::Meta::ArrayModel]
+      field :items, Icss::Meta::TypeFactory, :required => true
+      #
+      after_receive(:register){ true } # don't register
+      def fullname
+        return @fullname if @fullname
+        slug = (Type.klassname_for(items) || object_id.to_s).gsub(/^:*Icss:+/, '').gsub(/:+/, 'Dot')
+        @fullname = "ArrayOf#{slug}"
+      end
+      #
+      def self.receive(hsh)
+        hsh.symbolize_keys!
+        warn "Suspicious key :values - array schema takes :items (#{hsh})" if hsh.has_key?(:values)
+        val = super(hsh)
+        raise ArgumentError, "Items Factory is no good: #{hsh} - #{val._schema.to_hash}" if val.items.blank?
+        val
+      end
+      def to_hash
+        { :type => :array, :items => Type.schema_for(items) }
+      end
+      def type() :array ; end
+    end
+
+    #
+    # HashSchema describes an Avro Map type (which corresponds to a Ruby
+    # Hash).
+    #
+    # Hashes use the type name "hash" (or "map") and support one attribute:
+    #
+    # * values: the schema of the map's values. Avro Map keys are assumed to be strings.
+    #
+    # @example, a map from string to long is declared with:
+    #
+    #     {"type": "map", "values": "long"}
+    #
+    class HashSchema < ::Icss::Meta::StructuredSchema
+      self.parent_klass     = Hash
+      self.klass_metatypes += [::Icss::Meta::HashType]
+      field :values, Icss::Meta::TypeFactory, :required => true
+      #
+      after_receive(:register){ true } # don't register
+      def fullname
+        return @fullname if @fullname
+        slug = (Type.klassname_for(values) || object_id.to_s).gsub(/^:*Icss:+/, '').gsub(/:+/, 'Dot')
+        self.fullname = "HashOf#{slug}"
+      end
+      #
+      def self.receive(hsh)
+        hsh.symbolize_keys!
+        warn "Suspicious key :items - hash schema takes :values (#{hsh})" if hsh.has_key?(:items)
+        val = super(hsh)
+        raise ArgumentError, "Value Factory is no good: #{hsh} - #{val._schema}" if val.values.blank?
+        val
+      end
+      def to_hash
+        { :type => :map, :values => Type.schema_for(values) }
+      end
+      def type() :map ; end
+    end # HashSchema
+
+    #
+    # An EnumSchema escribes an Enum type.
+    #
+    # Enums use the type name "enum" and support the following attributes:
+    #
+    # name:       a string providing the name of the enum (required).
+    # namespace:  a string that qualifies the name;
+    # doc:        a string providing documentation to the user of this schema (optional).
+    # symbols:    an array, listing symbols, as strings or ruby symbols (required). All
+    #             symbols in an enum must be unique; duplicates are prohibited.
+    #
+    # For example, playing card suits might be defined with:
+    #
+    # { "type": "enum",
+    #   "name": "Suit",
+    #   "symbols" : ["SPADES", "HEARTS", "DIAMONDS", "CLUBS"]
+    # }
+    #
+    class EnumSchema < ::Icss::Meta::StructuredSchema
+      self.parent_klass     = Symbol
+      self.klass_metatypes += [::Icss::Meta::EnumType]
+      field      :symbols, Array,  :items => Symbol, :required => true
+      def type() :enum ; end
+    end # EnumSchema
+
+    #
+    # Description of an Fixed type.
+    #
+    # Fixed uses the type name "fixed" and supports the attributes:
+    #
+    # * name: a string naming this fixed (required).
+    # * namespace, a string that qualifies the name;
+    # * size: an integer, specifying the number of bytes per value (required).
+    #
+    #   For example, 16-byte quantity may be declared with:
+    #
+    #     {"type": "fixed", "size": 16, "name": "md5"}
+    #
+    class FixedSchema < ::Icss::Meta::StructuredSchema
+      self.parent_klass     = String
+      self.klass_metatypes += [::Icss::Meta::FixedType]
+      field     :size,    Integer, :validates => { :numericality => { :greater_than => 0 }}
+      def type() :fixed ; end
+    end # FixedSchema
+
+    #
+    # Description of a simple type (derived from one of the base classes)
+    #
+    # Simple uses the type name "simple" and supports the attributes:
+    #
+    # * name: a string naming this fixed (required).
+    # * namespace, a string that qualifies the name;
+    #
+    class SimpleSchema < ::Icss::Meta::NamedSchema
+      field :basename,         Symbol, :required => true
+      field :namespace,        String
+      field :is_a,             Array, :default => [], :items => Icss::Meta::TypeFactory
+      field :doc,              String, :required => true
+      rcvr_alias :name, :basename
+      self.klass_metatypes = [::Icss::Meta::NamedType]
+
+      def basename=(s)
+        segs = s.to_s.split(/\./)
+        @basename = segs.pop.to_sym
+        @namespace = segs.join('.').to_s if segs.present?
+      end
+      def receive_basename(s) self.basename = s.to_sym ; end
+
+      def fullname
+        [namespace, basename].compact_blank.join('.')
+      end
+
+      def type() :simple ; end
+      #
+      def parent_klass()      is_a.first ; end
+      def parent_metamodels()
+        return [] if is_a.length <= 1
+        is_a[1 .. -1].map{|pk| pk.metamodel if pk.respond_to?(:metamodel) }.compact
+      end
+    end # SimpleSchema
+
+  end
+end

data/lib/icss/type/type_factory.rb

@@ -0,0 +1,144 @@
+module Icss
+  module Meta
+
+    # Receives any object just as given.
+    #
+    # @example
+    #   # receive_foo accepts the item just as given
+    #   field :foo, Icss::Meta::IdenticalFactory
+    #
+    class IdenticalFactory
+      def self.receive(obj)
+        obj
+      end
+    end
+
+    class IdenticalHashFactory
+      def self.to_schema() { :type => 'map' } ; end
+      def self.receive(obj)
+        unless obj.nil? || obj.respond_to?(:each_pair) then raise(ArgumentError, "Must supply a hashlike value, got #{obj.to_s[0..100]}") ; end
+        obj
+      end
+    end
+
+    class IdenticalArrayFactory
+      def self.to_schema() { :type => 'array' } ; end
+      def self.receive(obj)
+        unless obj.nil? || obj.respond_to?(:each) then raise(ArgumentError, "Must supply an arraylike value, got #{obj.to_s[0..100]}") ; end
+        obj
+      end
+    end
+
+    module TypeFactory
+
+      ::Icss::FACTORY_TYPES.merge!({
+          Icss::Meta::TypeFactory       => Icss::Meta::TypeFactory,
+          Object                        => Icss::Meta::IdenticalFactory,
+          Icss::Meta::IdenticalFactory  => Icss::Meta::IdenticalFactory,
+        })
+
+      #
+      # A Schema is represented by one of:
+      #
+      # * A symbol or string, naming a defined type.
+      # * A class that responds to +.receive+, returned as itself
+      # * A hash (respond_to?(:each_pair), of the form:
+      #       {"type": "typename" ...attributes...}
+      #   where typename is either a simple or derived type name, as defined
+      #   in the Icss::Type class
+      # * An array, representing a union of embedded types.
+      #
+      def self.receive schema
+        flavor, klass = classify_schema_declaration(schema)
+        # p ['tfr', __FILE__, flavor, klass, schema]
+        case flavor
+        when :simple            then return klass
+        when :factory           then return klass
+        when :is_type           then return klass
+        when :structured_schema then return receive_structured_schema(klass, schema)
+        when :union_schema      then return receive_union_schema(klass, schema)
+        when :named_type        then return receive_named_type(klass, schema)
+        else
+        end
+      end
+
+      #
+      # A Schema is represented by one of:
+      #
+      # * A symbol or string, naming a defined type.
+      # * A class that responds to +.receive+, returned as itself
+      # * A hash (respond_to?(:each_pair), of the form:
+      #       {"type": "typeName" ...attributes...}
+      #   where typeName is either a simple or derived type name, as defined
+      #   in the Icss::Type class
+      # * An array, representing a union of embedded types.
+      #
+      #
+      def self.classify_schema_declaration(schema)
+        if schema.respond_to?(:each_pair)
+          schema.symbolize_keys!
+          type = schema[:type]
+        else type = schema
+        end
+        type = type.to_sym if type.respond_to?(:to_sym)
+        # p ['clfy', __FILE__, schema, type]
+
+        # FIXME -- make this match the preamble comment
+
+        if    type.is_a?(Module) && type < NamedType          then return [:is_type,           type]
+        elsif ::Icss::SIMPLE_TYPES.include?(type)             then return [:simple,            SIMPLE_TYPES[type]]
+        elsif (type == Array) && schema[:items].blank?        then return [:factory,           IdenticalArrayFactory]
+        elsif (type == Hash)  && schema[:values].blank?       then return [:factory,           IdenticalHashFactory]
+        elsif ::Icss::FACTORY_TYPES.include?(type)            then return [:factory,           FACTORY_TYPES[type]]
+        elsif ::Icss::STRUCTURED_SCHEMAS.include?(type)       then return [:structured_schema, STRUCTURED_SCHEMAS[type]]
+        elsif (type == :base)                                 then return [:is_type,           schema[:name].camelize.constantize]
+        elsif (type == :union) || type.is_a?(Array)           then return [:union_schema,      Icss::Meta::UnionSchema]
+        elsif type.is_a?(Symbol) && type.to_s =~ /^[\w\.\:]+/ then return [:named_type,        type]
+        elsif type.is_a?(Class) || type.is_a?(Module)         then return [:is_type,           type]
+        elsif type.respond_to?(:each_pair)                    then return [:is_type,           receive(type)]
+        else  raise ArgumentError, %Q{Can not classify #{schema.inspect}: should be the handle for a named type; one of #{SIMPLE_TYPES.keys.join(',')}; a schema of the form {"type": "typename" ...attributes....}; or an array (representing a union type).}
+        end
+      end
+
+      def self.with_namespace(def_ns)
+        old_def_ns = @default_namespace
+        @default_namespace = def_ns
+        ret = yield
+        @default_namespace = old_def_ns
+        ret
+      end
+
+      def self.namespaced_name(nm)
+        nm = nm.to_s
+        return nm if (nm == 'thing') || (nm =~ /[\.\/]/)
+        [@default_namespace, nm].compact.join('.')
+      end
+
+    protected
+
+      def self.receive_named_type(type_name, schema)
+        ns_name   = namespaced_name(type_name)
+        klass_name = Icss::Meta::Type.klassname_for(ns_name.to_sym)
+        # p ['rnt', type_name, schema, ns_name, klass_name]
+        begin
+          klass_name.constantize
+        rescue NameError => e
+          # Log.debug "auto loading core type #{ns_name} - #{schema}" if defined?(Log)
+          Icss::Meta::Type.find(ns_name)
+        end
+      end
+
+      def self.receive_structured_schema(schema_writer, schema)
+        if (schema[:name].to_s !~ /[\.\/]/) && @default_namespace && (schema[:name].to_s != 'thing')
+          schema[:namespace] ||= @default_namespace
+        end
+        schema_writer.receive(schema)
+      end
+
+      def self.receive_union_schema(schema_writer, schema)
+        schema_writer.receive(schema)
+      end
+
+    end
+  end
+end

data/lib/icss/type/union_schema.rb

@@ -0,0 +1,41 @@
+module Icss
+  module Meta
+
+    #
+    # Describes an Avro Union type.
+    #
+    # Unions are represented using JSON arrays. For example, ["string", "null"]
+    # declares a schema which may be either a string or null.
+    #
+    # Unions may not contain more than one schema with the same type, except for
+    # the named types record, fixed and enum. For example, unions containing two
+    # array types or two map types are not permitted, but two types with different
+    # names are permitted. (Names permit efficient resolution when reading and
+    # writing unions.)
+    #
+    # Unions may not immediately contain other unions.
+    #
+    class UnionSchema
+      #   extend Icss::Meta::ContainerType
+      #   #
+      #   attr_accessor :embedded_types
+      #   attr_accessor :declaration_flavors
+      #   #
+      #   def receive! type_list
+      #     self.declaration_flavors = []
+      #     self.embedded_types = type_list.map do |schema|
+      #       type = TypeFactory.receive(schema)
+      #       declaration_flavors << TypeFactory.classify_schema_declaration(schema)
+      #       type
+      #     end
+      #   end
+      #   def to_schema
+      #     embedded_types.zip(declaration_flavors).map do |t,fl|
+      #       [:structured_schema].include?(fl) ? t.name : t.to_schema
+      #     end
+      #   end
+      # end
+
+    end
+  end
+end