icss-activesupport-4 0.4.0

data/lib/icss/type.rb

@@ -0,0 +1,168 @@
+module Icss
+  module Meta
+    module Type
+      include Icss::ReceiverModel::ActsAsCatalog
+      def self.catalog_sections
+        ::Icss::Meta::Protocol.catalog_sections
+      end
+      def self.receive(hsh)
+        ::Icss::Meta::Protocol.receive(hsh)
+      end
+    end
+  end
+
+  #
+  # Predefining the namespaces here makes inclusion-order less brittle.
+  #
+
+  # full definitions in type/simple_types.rb
+  class ::Boolean < ::BasicObject ; end
+  class ::Long    < ::Integer     ; end
+  class ::Double  < ::Float       ; end
+  class ::Binary  < ::String      ; end
+
+  # patron saint of Simple Types (Structured Text)
+  module St       ; end
+  # pasture wherein graze MeasurementUnits
+  module Mu       ; end
+  # stand in the place where you are
+  module Business ;  end
+  #
+  module Culture  ;  end
+  # we gots the whhole worl innour hans
+  module Encyclopedic ; end
+  # Eventfully, Tom phoned the caterer.
+  module Ev       ; end
+  #
+  module Geo      ; end
+  # Relatively speaking, this is where links and relations go
+  module Rel      ; end
+  # I don't want to sell anything, buy anything, or process anything as a career.
+  # I don't want to sell anything bought or processed, or buy anything sold or processed, or process
+  # anything sold, bought, or processed, or repair anything sold, bought, or processed.
+  # You know, as a career, I don't want to do that.
+  module Prod     ;  end
+  #
+  module Social   ; end
+  # Oh what a tangled web we weave when first we practice to receive
+  module Web      ; end
+  # Raw records, for use by data mungers
+  module Raw      ; end
+
+  # Buffalo Buffalo buffalo Buffalo Buffalo Buffalo buffalo.
+  module Meta
+    # full definitions in type/structured_schema.rb and type/union_schema.rb
+    class NamedSchema  ; end
+    class SimpleSchema < NamedSchema      ; end
+    class UnionSchema      < NamedSchema      ; end
+    class RecordSchema     < SimpleSchema     ; end
+    class ErrorSchema      < RecordSchema     ; end
+    #
+    class StructuredSchema < NamedSchema      ; end
+    class HashSchema       < StructuredSchema ; end
+    class ArraySchema      < StructuredSchema ; end
+    class FixedSchema      < StructuredSchema ; end
+    class EnumSchema       < StructuredSchema ; end
+  end
+
+  ::Icss::SIMPLE_TYPES       = {} unless defined?( ::Icss::SIMPLE_TYPES       )
+  ::Icss::FACTORY_TYPES      = {} unless defined?( ::Icss::FACTORY_TYPES      )
+  ::Icss::STRUCTURED_SCHEMAS = {} unless defined?( ::Icss::STRUCTURED_SCHEMAS )
+  ::Icss::UNION_SCHEMAS      = {} unless defined?( ::Icss::UNION_SCHEMAS      )
+
+  unless defined?(::Icss::AVRO_TYPES)
+    ::Icss::AVRO_TYPES = {
+      :null     => ::NilClass,
+      :boolean  => ::Boolean,
+      :int      => ::Integer,
+      :long     => ::Long,
+      :float    => ::Float,
+      :double   => ::Double,
+      :string   => ::String,
+      :bytes    => ::Binary,
+    }.freeze
+  end
+  ::Icss::SIMPLE_TYPES.merge!(::Icss::AVRO_TYPES)
+
+  ::Icss::SIMPLE_TYPES.merge!({
+      :binary  => ::Binary,
+      :symbol  => ::Symbol,
+      :time    => ::Time,
+      :integer => ::Integer,
+      :numeric => ::Numeric,
+      :regexp  => ::Regexp,
+    })
+
+  ::Icss::STRUCTURED_SCHEMAS.merge!({
+      :simple  => Icss::Meta::SimpleSchema,
+      :record  => Icss::Meta::RecordSchema,
+      :error   => Icss::Meta::ErrorSchema,
+      :map     => Icss::Meta::HashSchema,
+      :hash    => Icss::Meta::HashSchema,
+      Hash     => Icss::Meta::HashSchema,
+      :array   => Icss::Meta::ArraySchema,
+      Array    => Icss::Meta::ArraySchema,
+      :fixed   => Icss::Meta::FixedSchema,
+      :enum    => Icss::Meta::EnumSchema,
+    })
+  ::Icss::UNION_SCHEMAS.merge!({
+      :union   => Icss::Meta::UnionSchema,
+    })
+
+  module Meta
+    module Type
+      #:nodoc:
+      NORMAL_NAMED_CONSTANT_RE = /\A[\w\:\.]+\z/ unless defined?(NORMAL_NAMED_CONSTANT_RE)
+
+      # Turns a type name into its dotted (avro-style) name, regardless of its
+      # current form.
+      #
+      # @example
+      #    Icss::Meta::Type.fullname_for(Icss::This::That::TheOther)   # 'this.that.the_other'
+      #    Icss::Meta::Type.fullname_for("Icss::This::That::TheOther") # 'this.that.the_other'
+      #    Icss::Meta::Type.fullname_for('this.that.the_other')        # 'this.that.the_other'
+      #
+      def self.fullname_for(klass_name)
+        return nil unless klass_name.present? && (klass_name.to_s =~ NORMAL_NAMED_CONSTANT_RE)
+        klass_name.to_s.gsub(/^:*Icss::/, '').underscore.gsub(%r{/},".")
+      end
+
+      # Converts a type name to its ruby (camel-cased) form. Works on class,
+      # name of class, or dotted (avro-style) namespace.name. Names will have
+      # an 'Icss::' prefix.
+      #
+      # @example
+      #    Icss::Meta::Type.fullname_for('this.that.the_other')        # "Icss::This::That::TheOther"
+      #    Icss::Meta::Type.fullname_for(Icss::This::That::TheOther)   # "Icss::This::That::TheOther"
+      #    Icss::Meta::Type.fullname_for("Icss::This::That::TheOther") # "Icss::This::That::TheOther"
+      #
+      def self.klassname_for(obj)
+        return nil unless obj.present? && (obj.to_s =~ NORMAL_NAMED_CONSTANT_RE)
+        nm = obj.to_s.gsub(/^:*Icss:+/, '').
+          gsub(%r{::},'.').
+          split('.').map(&:camelize).join('::')
+        "::Icss::#{nm}"
+      end
+
+      def self.schema_for(obj)
+        case
+        when obj.respond_to?(:to_schema) then obj.to_schema
+        when str = fullname_for(obj)     then str.to_sym
+        else nil ; end
+      end
+
+      # true if class is among the defined primitive types:
+      #   null boolean integer long float double string binary
+      # and so forth
+      #
+      # note this takes no account of inheritance -- only the types specifically
+      # listed in Icss::SIMPLE_TYPES are simple
+      def self.simple?(tt)    ::Icss::SIMPLE_TYPES.has_value?(tt)    ; end
+
+      def self.union?(tt)     false     ; end
+
+      def self.record?(tt)    false     ; end
+
+    end
+  end
+end

data/lib/icss/type/named_type.rb

@@ -0,0 +1,185 @@
+module Icss
+  module Meta
+
+    #
+    # Record, Error, Enum and Fixed are named types. Each has a fullname that is
+    # composed of two parts; a name and a namespace. Equality of names is
+    # defined on the fullname.
+    #
+    # The name portion of a fullname, and record field names, must:
+    #
+    # * start with [A-Za-z_]
+    # * subsequently contain only [A-Za-z0-9_]
+    # * A namespace is a dot-separated sequence of such names.
+    #
+    # References to previously defined names are as in the latter two cases above:
+    # if they contain a dot they are a fullname, if they do not contain a dot, the
+    # namespace is the namespace of the enclosing definition.
+    #
+    # Simple type names have no namespace and their names may not be defined in
+    # any namespace. A schema may only contain multiple definitions of a
+    # fullname if the definitions are equivalent.
+    #
+    module NamedType
+      def doc() "" end
+      def doc=(str)
+        singleton_class.class_eval do
+          remove_possible_method(:doc)
+          define_method(:doc){ str }
+        end
+      end
+      #
+      def fullname
+        ::Icss::Meta::Type.fullname_for(self.name)
+      end
+      def basename
+        @basename  ||= fullname.to_s.gsub(/.*[\.]/, "")
+      end
+      def namespace
+        @namespace ||= fullname.to_s.include?('.') ? fullname.to_s.gsub(/\.[^\.]+\z/so, '') : ''
+      end
+      def pathname
+        fullname.to_s.gsub(/\./, '/')
+      end
+      #
+      def to_schema
+        if respond_to?(:_schema) then return _schema.to_hash ; end
+        {
+          :name      => fullname,
+          # :namespace => namespace,
+          :doc       => doc,
+        }.compact_blank
+      end
+
+      def is_core?
+        respond_to?(:_schema) && _schema.is_core?
+      end
+
+      # ---------------------------------------------------------------------------
+      #
+      # Type Factory methods
+      #
+
+      #
+      # Returns the metamodel -- a module extending the type, on which all the
+      # accessors and receive methods are inscribed. (This allows you to call
+      # +super()+ from within receive_foo)
+      #
+      def metamodel
+        return @metamodel if @metamodel
+        @metamodel = Icss::Meta::NamedType.get_meta_module(self.to_s)
+        self.class_eval{ include(@metamodel) }
+        @metamodel
+      end
+
+      #
+      # Manufactures klass and metamodel
+      #
+      # for type science.astronomy.ufo_sighting, we synthesize
+      # * a module, ::Icss::Meta::Science::Astronomy::UfoSightingType
+      # * a class,  ::Icss::Science::Astronomy::UfoSighting
+      #
+      # If no superklass is given, Icss::Entity is used.
+      def self.make(fullname, superklass)
+        klass    = get_model_klass(fullname, superklass)
+        metamodel = get_meta_module(klass.to_s)
+        klass.class_eval{ extend(::Icss::Meta::NamedType) }
+        klass.class_eval{ include(metamodel) }
+        [klass, metamodel]
+      end
+
+    protected
+
+      def define_metamodel_method(meth_name, visibility=:public, &blk)
+        metamodel.class_eval do
+          define_method(meth_name, &blk) unless method_defined?(meth_name)
+          case visibility
+          when :protected then protected meth_name
+          when :private   then private   meth_name
+          when :public    then public    meth_name
+          else raise ArgumentError, "visibility must be :public, :private or :protected"
+          end
+        end
+      end
+
+      # Returns the klass for the given scope and name, starting with '::Icss'
+      # and creating all necessary parents along the way. Note that if the given
+      # class or its parent scopes already exist, they're trusted to be correct
+      # -- we don't do any error checking as to their type or superclass.
+      #
+      # @example
+      #   Icss::Meta::Type.get_model_klass('this.that.the_other')
+      #   # Icss::This::That::TheOther
+      #
+      # @param scope_names [Array of String]
+      # @param superklass  [Class] - the superclass to use if the class doesn't exist.
+      def self.get_model_klass(fn, superklass)
+        fullname = Icss::Meta::Type.fullname_for(fn)
+        return Class.new(superklass) if fullname.nil?
+        #
+        scope_names   = scope_names_for(fullname)
+        klass_name    = scope_names.pop
+        parent_module = get_nested_module(%w[Icss] + scope_names)
+
+        # const_defined?(klass, inherit), const_get(klass, inherit)
+        # inherit = false makes these methods be scoped to parent_module instead of universally
+        if parent_module.const_defined?(klass_name, false)
+          klass = parent_module.const_get(klass_name, false)
+          # #{superklass.object_id}: #{klass.ancestors.map{|o| [o, o.object_id] }}
+          unless klass.ancestors.include?(superklass)
+            warn "+++++++++++++++++++++++++++++++ Superclass and is_a? mismatch for #{klass.inspect} (doesn't inherit from #{superklass.inspect})"
+            # p [klass_name, klass, Icss::Thing.object_id, ::Icss::Thing.object_id, Icss.const_get(:Thing).object_id,]
+            # p klass      .ancestors.flatten.map{|t| [t, t.object_id]}
+            # p Icss::Thing.ancestors.flatten.map{|t| [t, t.object_id]}
+          end
+          klass
+        else
+          parent_module.const_set(klass_name, Class.new(superklass))
+        end
+      end
+
+      # Returns the meta-module for the given scope and name, starting with
+      # '::Icss::Meta' and creating all necessary parents along the way.
+      #
+      # @example
+      #   Icss::Meta::TypeFactory.get_meta_module(["This", "That"], "TheOther")
+      #   # Icss::Meta::This::That::TheOtherModel
+      def self.get_meta_module(fullname)
+        fullname = Icss::Meta::Type.fullname_for(fullname)
+        return Module.new if fullname.nil?
+        #
+        scope_names      = scope_names_for(fullname)
+        scope_names[-1] += "Model"
+        get_nested_module(%w[Icss Meta] + scope_names)
+      end
+
+      # Turns a dotted namespace.name into camelized rubylike names for a class
+      # @example
+      #   scope_names_for('this.that.the_other')
+      #   # ["This", "That", "TheOther"]
+      def self.scope_names_for(fullname)
+        fullname.split('.').map(&:camelize)
+      end
+
+      # Returns a module for the given scope names, rooted always at Object (so
+      # implicity with '::').
+      # @example
+      #   get_nested_module(["This", "That", "TheOther"])
+      #   # This::That::TheOther
+      def self.get_nested_module(scope_names)
+        scope_names.inject(Object) do |parent_module, module_name|
+
+          # const_defined?(klass, inherit), const_get(klass, inherit)
+          # inherit = false makes these methods be scoped to parent_module instead of universally
+          if parent_module.const_defined?(module_name, false)
+            parent_module.const_get(module_name, false)
+          else
+            parent_module.const_set(module_name.to_sym, Module.new)
+          end
+        end
+      end
+
+    end
+
+  end
+end

data/lib/icss/type/record_field.rb

@@ -0,0 +1,77 @@
+module Icss
+  module Meta
+
+    class RecordField
+      include Icss::Meta::RecordModel
+      include Icss::ReceiverModel::ActsAsHash
+      include Gorillib::Hashlike
+      include Gorillib::Hashlike::Keys
+      include Icss::ReceiverModel
+      include Icss::ReceiverModel::ActiveModelShim
+      remove_possible_method(:type)
+
+      ALLOWED_ORDERS = %w[ascending descending ignore].freeze unless defined?(ALLOWED_ORDERS)
+
+      field :name,       Symbol,                  :required => true
+      field :type,       Icss::Meta::TypeFactory, :required => true
+      field :doc,        String
+      field :default,    Icss::Meta::IdenticalFactory
+      field :replace,    Hash
+      field :required,   Boolean
+      field :aliases,    Array,   :items => Symbol
+      field :order,      String,  :validates => { :inclusion => { :in => ALLOWED_ORDERS } }
+      field :accessor,   Symbol
+      field :receiver,   Symbol
+      field :validates,  Hash
+      rcvr_remaining :_extra_params
+      attr_accessor :parent
+
+      # FIXME: cruft
+      field :indexed_on, Symbol
+      field :identifier, Boolean, :doc => 'indicates the field is suitable for use'
+
+      after_receive(:warnings) do |hsh|
+        # warn "Extra params given to field #{self}: #{_extra_params.inspect}" if _extra_params.present?
+        warn "Validation failed for field #{self}: #{errors.inspect}" if respond_to?(:errors) && (not valid?)
+      end
+
+      # track recursion of type references
+      after_receive(:am_i_a_reference) do |hsh|
+        hsh = hsh.symbolize_keys
+        nonreference_klasses = [::Icss::Meta::ArrayType, ::Icss::Meta::HashType, ::Icss::Meta::EnumType, ::Icss::Meta::FixedType]
+
+        @is_reference = (hsh[:type].is_a?(String) || hsh[:type].is_a?(Symbol) || (hsh[:type].is_a?(Class) && nonreference_klasses.none?{|klass| hsh[:type].is_a?(klass) }))
+      end
+
+      # is the field a reference to a named type (true), or an inline schema (false)?
+      def is_reference?() @is_reference ; end
+
+      def to_hash()
+        hsh = super
+        hsh = hsh.merge({ :type => (is_reference? ? type.fullname : Type.schema_for(type)) })
+        hsh.delete(:_extra_params)
+        hsh
+      end
+      def to_schema
+        to_hash
+      end
+
+      # Hack hack -- makes it so fields go thru the receiver door when merged in RecordType
+      def merge(hsh)
+        dup.receive!(hsh)
+      end
+
+      # Order is defined by the avro spec
+      def order()           @order || 'ascending' ; end
+      def order_direction() case order when 'ascending' then 1 when 'descending' then -1 else 0 ; end ; end
+    end
+
+    module RecordType
+    protected
+      # create new field_schema as a RecordField object, not Hash
+      def make_field_schema
+        RecordField.new
+      end
+    end
+  end
+end

data/lib/icss/type/record_model.rb

@@ -0,0 +1,49 @@
+module Icss
+  module Meta
+
+    module RecordModel
+      def self.included(base)
+        base.extend(Icss::Meta::RecordType)
+        base.metamodel
+      end
+
+      #
+      # modify object in place with new typecast values.
+      #
+      def receive!(hsh={})
+        raise ArgumentError, "Can't receive (it isn't hashlike): {#{hsh.inspect}}" unless hsh.respond_to?(:[]) && hsh.respond_to?(:has_key?)
+        self.class.send(:_rcvr_methods).each do |attr, meth|
+          if    hsh.has_key?(attr)      then val = hsh[attr]
+          elsif hsh.has_key?(attr.to_s) then val = hsh[attr.to_s]
+          else next ; end
+          self.send(meth, val)
+        end
+        run_after_receivers(hsh)
+        self
+      end
+
+      # true if the attr is a receiver variable and it has been set
+      def attr_set?(attr)
+        self.class.has_field?(attr) && self.instance_variable_defined?("@#{attr}")
+      end
+
+      def unset!(attr)
+        self.send(:remove_instance_variable, "@#{attr}") if self.instance_variable_defined?("@#{attr}")
+      end
+      protected :unset!
+
+    protected
+
+      def run_after_receivers(hsh)
+        self.class.after_receivers.each do |after_hook_name, after_hook|
+          self.instance_exec(hsh, &after_hook)
+        end
+      end
+
+      def _set_field_val(field_name, val)
+        self.instance_variable_set("@#{field_name}", val)
+      end
+
+    end
+  end
+end