icss 0.1.3 → 0.3.2

data/lib/icss/receiver_model/acts_as_loadable.rb

@@ -0,0 +1,47 @@
+require 'yaml'
+require 'json' unless defined?(JSON)
+
+module Icss
+  module ReceiverModel
+
+    #
+    # adds methods to load and store from json, yaml or magic
+    #
+    # This will require 'json' UNLESS you have already included something (so if
+    # you want to say require 'yajl/json_gem' then do that first).
+    #
+    module ActsAsLoadable
+      module ClassMethods
+
+        # module ::Icss::ReceiverModel::ClassMethods
+        #   include Icss::ReceiverModel::ActsAsLoadable::ClassMethods
+        # end
+
+        def receive_json stream
+          receive(JSON.load(stream))
+        end
+
+        def receive_yaml stream
+          receive(YAML.load(stream))
+        end
+
+        #
+        # The file is loaded with
+        # * YAML if the filename ends in .yaml or .yml
+        # * JSON otherwise
+        #
+        def receive_from_file filename
+          stream = File.open(filename)
+          (filename =~ /.ya?ml$/) ? receive_yaml(stream) : receive_json(stream)
+        end
+      end
+
+      def merge_from_file! filename
+        other_obj = self.class.receive_from_file(filename)
+        tree_merge! other_obj
+      end
+    end
+    
+  end
+
+end

data/lib/icss/receiver_model/acts_as_tuple.rb

@@ -0,0 +1,100 @@
+module Icss
+  module ReceiverModel
+    module ActsAsTuple
+
+      def to_tuple
+        tuple = []
+        self.each_value do |val|
+          if val.respond_to?(:to_tuple)
+            tuple += val.to_tuple
+          else
+            tuple << val
+          end
+        end
+        tuple
+      end
+
+      module ClassMethods
+
+        # returns a depth-first traversal of the object's fields' keys, as Strings:
+        #
+        #   class Address < Icss::Thing
+        #     field(:housenum, Integer)
+        #     field(:street, String)
+        #   end
+        #   class Person <  Icss::Thing
+        #     field(:full_name, String)
+        #     field(:street_address, Address)
+        #   end
+        #   Person.tuple_keys
+        #   # => ['fullname', 'street_address.housenum', 'street_address.street']
+        #
+        # @param [Integer] max_key_segments the maximum length of key (depth to
+        #   recurse); a stark 3 by default.
+        def tuple_keys(max_key_segments=3)
+          tuple_fields(max_key_segments).map{|field_set| field_set.map(&:name).join('.') }
+        end
+
+        # returns a depth-first traversal of the object's fields, as RecordFields:
+        #
+        #   class Address < Icss::Thing
+        #     field(:housenum, Integer)
+        #     field(:street, String)
+        #   end
+        #   class Person <  Icss::Thing
+        #     field(:full_name, String)
+        #     field(:street_address, Address)
+        #   end
+        #   Person.tuple_keys
+        #   # => [ [<RecordField name='fullname' ...>],
+        #   #      [<RecordField name='street_address' ...>, <RecordField name='housenum' ...>],
+        #   #      [<RecordField name='street_address' ...>, <RecordField name='street' ...>],
+        #
+        # Note that RecordField helpfully supplies a 'parent' attribute pointing to it parent record.
+        #
+        # @param [Integer] max_key_segments the maximum length of key (depth to
+        #   recurse); a stark 3 by default.
+        #
+        def tuple_fields(max_key_segments=3)
+          # return @tuple_fields if @tuple_fields
+          @tuple_fields = field_schemas.flat_map do |fn, fld|
+            if (max_key_segments > 1) && fld[:type].respond_to?(:tuple_fields)
+              fld[:type].tuple_fields(max_key_segments-1).map{|subfield| [fld, subfield].flatten }
+            else
+              [[fld]]
+            end
+          end
+        end
+
+        # walks through the tuple, destructively consuming each value in a
+        # depth-first walk of the field tree:
+        #
+        #   class Address < Icss::Thing
+        #     field(:housenum, Integer)
+        #     field(:street, String)
+        #   end
+        #   class Person <  Icss::Thing
+        #     field(:full_name, String)
+        #     field(:street_address, Address)
+        #   end
+        #   Person.consume_tuple(1214, 'W 6th St', 'Joe the Chimp')
+        #   # => #<Person street_address=#<Address housenum=1214, street='W 6th St'>, fullname='Joe the Chimp'>
+        #
+        def consume_tuple(tuple)
+          obj = self.new
+          fields.each do |field|
+            if field[:type].respond_to?(:consume_tuple)
+              val = field[:type].consume_tuple(tuple)
+            else
+              val = tuple.shift
+            end
+            obj.send("receive_#{field[:name]}", val) if val
+          end
+          obj.send(:run_after_receivers, {})
+          obj
+        end
+      end
+      def self.included(base) base.extend(Icss::ReceiverModel::ActsAsTuple::ClassMethods) ; end
+    end
+  end
+end

data/lib/icss/receiver_model/locale/en.yml

@@ -0,0 +1,27 @@
+en:
+  errors:
+    # The default format to use in full error messages.
+    format: "%{attribute} %{message}"
+
+    # The values :model, :attribute and :value are always available for interpolation
+    # The value :count is available when applicable. Can be used for pluralization.
+    messages:
+      inclusion:                "is not included in the list"
+      exclusion:                "is reserved"
+      invalid:                  "is invalid"
+      confirmation:             "doesn't match confirmation"
+      accepted:                 "must be accepted"
+      empty:                    "can't be empty"
+      blank:                    "can't be blank"
+      too_long:                 "is too long (maximum is %{count} characters)"
+      too_short:                "is too short (minimum is %{count} characters)"
+      wrong_length:             "is the wrong length (should be %{count} characters)"
+      not_a_number:             "is not a number"
+      not_an_integer:           "must be an integer"
+      greater_than:             "must be greater than %{count}"
+      greater_than_or_equal_to: "must be greater than or equal to %{count}"
+      equal_to:                 "must be equal to %{count}"
+      less_than:                "must be less than %{count}"
+      less_than_or_equal_to:    "must be less than or equal to %{count}"
+      odd:                      "must be odd"
+      even:                     "must be even"

data/lib/icss/receiver_model/to_geo_json.rb

@@ -0,0 +1,19 @@
+def test_icss
+  return <<EOF
+---
+namespace: foo.bar
+protocol: baz
+types:
+
+- name: place
+  doc: Foo bar place
+  type: record
+  fields:
+  - name: name
+    doc: Your name.
+    type: string
+  - name: website
+    doc: Your website.
+    type: url
+EOF
+end

data/lib/icss/receiver_model/tree_merge.rb

@@ -0,0 +1,34 @@
+module Icss
+  module ReceiverModel
+    # Recursively merges using receive
+    #
+    # Modifies the full receiver chain in-place.
+    #
+    # For each key in keys,
+    # * if self's value is nil, receive the attribute.
+    # * if self's attribute is an Array, append to it.
+    # * if self's value responds to tree_merge!, tree merge it.
+    # * if self's value responds_to merge!, merge! it.
+    # * otherwise, receive the value from other_hash
+    #
+    def tree_merge!(other_hash)
+      super(other_hash) do |key, self_val, other_val|
+        field = self.class.field_named(key)
+        if field && self_val.is_a?(Array) && field.has_key?(:indexed_on)
+          index_attr = field[:indexed_on]
+          other_val.each do |other_el|
+            other_el_name = other_el[index_attr]  or next
+            self_el  = self_val.find{|el| el[index_attr].to_s == other_el_name.to_s }
+            if self_el then  self_el.tree_merge!(other_el)
+            else self_val << other_el
+            end
+          end
+          self_val
+        else
+          false
+        end
+      end
+      self
+    end
+  end
+end

data/lib/icss/receiver_model/validations.rb

@@ -0,0 +1,31 @@
+module Icss
+  module ReceiverModel
+    module Validations
+      module ::Icss::ReceiverModel::ClassMethods
+        include ::Icss::ReceiverModel::Validations
+      end
+
+      #
+      # Sends the fields' validations on to Icss::Type::Validations.
+      # Uses syntax parallel to ActiveModel's:
+      #
+      #      :presence     => true
+      #      :uniqueness   => true
+      #      :numericality => true
+      #        :==, :>, :>=, :<, :<=, :odd?, :even?
+      #        (and spelled out: :equal_to, :less_than_or_equal_to, :odd, etc)
+      #      :length       => { :minimum => 0, maximum => 2000 }
+      #        :==, :>=, :<=, :is, :minimum, :maximum
+      #      :format       => { :with => /.*/ }
+      #      :inclusion    => { :in => [1,2,3] }
+      #      :exclusion    => { :in => [1,2,3] }
+      #
+      def add_validator(field_name)
+        field = field_named(field_name)
+        self.validates(field[:name], :presence => true ) if field[:required]
+        self.validates(field[:name], field[:validates] ) if field[:validates]
+        super(field_name) if defined?(super)
+      end
+    end
+  end
+end

data/lib/icss/serialization.rb

@@ -0,0 +1,51 @@
+module Icss
+  module Meta
+    module RecordModel
+
+      def to_zaml(z=ZAML.new)
+        hsh = self.to_wire
+        hsh.to_zaml(z)
+        z.to_s
+      end
+
+    end
+  end
+end
+
+# module Icss
+#   module Meta
+#     class RecordField
+#       # def as_json()
+#       #   { :name     => name,
+#       #     :type     => expand_type,
+#       #     :doc      => doc,
+#       #     :default  => default,
+#       #     :required => required,
+#       #     :order    => @order,
+#       #   }.reject{|k,v| v.nil? }
+#       # end
+#
+#       protected
+#       def expand_type
+#         case
+#         when is_reference? && type.respond_to?(:fullname) then type.fullname
+#         when is_reference?                            then '(_unspecified_)'
+#         when type.is_a?(Array)                        then type.map{|t| t.to_hash }
+#         when type.respond_to?(:to_hash)               then type.to_hash
+#         else type.to_s
+#         end
+#       end
+#     end
+#   end
+# end
+
+# module Icss::ReceiverModel
+#   def as_json(*args)
+#     {}.tap{|hsh| self.each{|k,v| hsh[k] = (v.respond_to?(:as_json) ? v.as_json : v) } }
+#     # to_hash.compact_blank
+#   end
+#   def to_json(*args)
+#     as_json.to_json(*args)
+#   end
+# end
+#

data/lib/icss/serialization/zaml.rb

@@ -0,0 +1,443 @@
+# -*- encoding: utf-8 -*-
+#
+# ZAML -- A partial replacement for YAML, writen with speed and code clarity
+#         in mind.  ZAML fixes one YAML bug (loading Exceptions) and provides
+#         a replacement for YAML.dump() unimaginatively called ZAML.dump(),
+#         which is faster on all known cases and an order of magnitude faster
+#         with complex structures.
+#
+# http://github.com/hallettj/zaml
+#
+# Authors: Markus Roberts, Jesse Hallett, Ian McIntosh, Igal Koshevoy, Simon Chiang
+#
+
+require 'yaml'
+
+class ZAML
+  VERSION = "0.1.4m"   unless defined?(::ZAML::VERSION)
+
+  attr_accessor :result, :indent
+  # line up simple value tokens at this vertical column
+  attr_accessor :valign
+
+  #
+  # Class Methods
+  #
+  def self.dump(stuff, where='', options={})
+    z = self.new(options)
+    stuff.to_zaml(z)
+    where << z.to_s
+  end
+
+  #
+  # Instance Methods
+  #
+  def initialize(options={})
+    reset!
+    self.valign = options[:valign]
+  end
+
+  def reset!
+    @result = []
+    @indent = nil
+    @structured_key_prefix = nil
+    Label.counter_reset
+    emit('--- ')
+  end
+
+  # for all code within the block, the cursor supplies
+  def nested(tail='  ')
+    old_indent = @indent
+    # @indent    = "#{@indent || "\n"}#{tail}"
+    @indent    = @indent ? "#{@indent}#{tail}" : "\n"
+    yield
+    @indent    = old_indent
+  end
+
+  def vpad(sep, key)
+    return emit("#{sep} ") unless valign
+    if    key.is_a?(Symbol)  then str = key.inspect
+    elsif key.is_a?(String)  then str = key
+    elsif key.is_a?(Numeric) then str = key.to_s
+    else  return emit("#{sep} ") ; end
+    keylen = ((@indent||"\n").length - 1) + str.length + sep.length
+    vlen   = valign - keylen
+    pad  = (vlen > 1) ? (" "*vlen) : " "
+    emit(sep+pad)
+  end
+
+  def emit(s)
+    @result << s
+    @recent_nl = false unless s.kind_of?(Label)
+    self.to_s
+  end
+  def nl(s='')
+    emit(@indent || "\n") unless @recent_nl
+    emit(s)
+    @recent_nl = true
+  end
+  def prefix_structured_keys(x)
+    @structured_key_prefix = x
+    yield
+    nl unless @structured_key_prefix
+    @structured_key_prefix = nil
+  end
+
+  def new_label_for(obj)
+    Label.new(obj,(Hash === obj || Array === obj) ? "#{@indent || "\n"}  " : ' ')
+  end
+  def first_time_only(obj)
+    if label = Label.for(obj)
+      emit(label.reference)
+    else
+      if @structured_key_prefix and not obj.is_a? String
+        emit(@structured_key_prefix)
+        @structured_key_prefix = nil
+      end
+      emit(new_label_for(obj))
+      yield
+    end
+    self.to_s
+  end
+
+  def to_s
+    @result.join.tap{|s| s << "\n" if s[-1..-1] != "\n" }
+  end
+  def inspect
+    res = to_s.inspect
+    res = res[0..29]+"..."+res[-20..-1] if res.length > 50
+    %Q{\#<ZAML ind=#{@indent.inspect} pfx=#{@structured_key_prefix} result='#{res}'>}
+  end
+
+  def self.padding(nlines)
+    Padding.new(nlines)
+  end
+
+  def no_comment(elt)
+    if elt.is_a?(ZAML::Comment) || elt.is_a?(ZAML::Padding)
+      elt.to_zaml(self)
+    else
+      yield
+    end
+  end
+
+  class Comment < String
+    def to_zaml(z=ZAML.new)
+      lines = self.split("\n",-1).map{|s| "# #{s}".strip }
+      lines.each{|line| z.nl ; z.emit(line) }
+    end
+  end
+
+  class Padding
+    def initialize(nlines)
+      @nlines = nlines
+    end
+    def to_zaml(z=ZAML.new)
+      @nlines.times{ z.nl ; z.emit('') }
+      z.to_s
+    end
+  end
+
+  #
+  # Label class -- resolves circular references
+  #
+  class Label
+    #
+    # YAML only wants objects in the datastream once; if the same object
+    #    occurs more than once, we need to emit a label ("&idxxx") on the
+    #    first occurrence and then emit a back reference (*idxxx") on any
+    #    subsequent occurrence(s).
+    #
+    # To accomplish this we keeps a hash (by object id) of the labels of
+    #    the things we serialize as we begin to serialize them.  The labels
+    #    initially serialize as an empty string (since most objects are only
+    #    going to be be encountered once), but can be changed to a valid
+    #    (by assigning it a number) the first time it is subsequently used,
+    #    if it ever is.  Note that we need to do the label setup BEFORE we
+    #    start to serialize the object so that circular structures (in
+    #    which we will encounter a reference to the object as we serialize
+    #    it can be handled).
+    #
+    def self.counter_reset
+      @@previously_emitted_object = {}
+      @@next_free_label_number = 0
+    end
+    def initialize(obj,indent)
+      @indent = indent
+      @this_label_number = nil
+      @@previously_emitted_object[obj.object_id] = self
+    end
+    def to_s
+      @this_label_number ? ('&id%03d%s' % [@this_label_number, @indent]) : ''
+    end
+    def reference
+      @this_label_number ||= (@@next_free_label_number += 1)
+      @reference         ||= '*id%03d' % @this_label_number
+    end
+    def self.for(obj)
+      @@previously_emitted_object[obj.object_id]
+    end
+  end
+
+end
+
+################################################################
+#
+#   Behavior for custom classes
+#
+################################################################
+
+class Object
+  def to_yaml_properties
+    instance_variables.sort        # Default YAML behavior
+  end
+  def zamlized_class_name(root)
+    "!ruby/#{root.name.downcase}#{self.class == root ? '' : ":#{self.class.name}"}"
+  end
+  def to_zaml(z=ZAML.new)
+    z.first_time_only(self) {
+      z.emit(zamlized_class_name(Object))
+      z.nested {
+        instance_variables = to_yaml_properties
+        if instance_variables.empty?
+          z.emit(" {}")
+        else
+          instance_variables.each { |v|
+            z.nl
+            v[1..-1].to_zaml(z)       # Remove leading '@'
+            z.emit(': ')
+            instance_variable_get(v).to_zaml(z)
+          }
+        end
+      }
+    }
+  end
+end
+
+################################################################
+#
+#   Behavior for built-in classes
+#
+################################################################
+
+class NilClass
+  def to_zaml(z=ZAML.new)
+    z.emit('')        # NOTE: blank turns into nil in YAML.load
+  end
+end
+
+class Symbol
+  def to_zaml(z=ZAML.new)
+    z.emit(self.inspect)
+  end
+end
+
+class TrueClass
+  def to_zaml(z=ZAML.new)
+    z.emit('true')
+  end
+end
+
+class FalseClass
+  def to_zaml(z=ZAML.new)
+    z.emit('false')
+  end
+end
+
+class Numeric
+  def to_zaml(z=ZAML.new)
+    z.emit(self)
+  end
+end
+
+class Regexp
+  def to_zaml(z=ZAML.new)
+    z.first_time_only(self) { z.emit("#{zamlized_class_name(Regexp)} #{inspect}") }
+  end
+end
+
+class Exception
+  def to_zaml(z=ZAML.new)
+    z.emit(zamlized_class_name(Exception)+" ")
+    z.nested {
+      z.nl("message: ")
+      message.to_zaml(z)
+    }
+    z.to_s
+  end
+  #
+  # Monkey patch for buggy Exception restore in YAML
+  #
+  #     This makes it work for now but is not very future-proof; if things
+  #     change we'll most likely want to remove this.  To mitigate the risks
+  #     as much as possible, we test for the bug before appling the patch.
+  #
+  if respond_to? :yaml_new and yaml_new(self, :tag, "message" => "blurp").message != "blurp"
+    def self.yaml_new( klass, tag, val )
+      o = YAML.object_maker( klass, {} ).exception(val.delete( 'message'))
+      val.each_pair do |k,v|
+        o.instance_variable_set("@#{k}", v)
+      end
+      o
+    end
+  end
+end
+
+ZAML::NUM_RE    = '[-+]?(0x)?\d+\.?\d*' unless defined?(::ZAML::NUM_RE)
+ZAML::SIMPLE_STRING_RE = /\A(true|false|yes|no|on|null|off|#{ZAML::NUM_RE}(:#{ZAML::NUM_RE})*|!|=|~|>|\||\n+)\z/io  # unless defined?(::ZAML::SIMPLE_STRING_RE)
+ZAML::ZAML_ESCAPES = %w{\x00 \x01 \x02 \x03 \x04 \x05 \x06 \a \x08 \t \n \v \f \r \x0e \x0f \x10 \x11 \x12 \x13 \x14 \x15 \x16 \x17 \x18 \x19 \x1a \e \x1c \x1d \x1e \x1f } unless defined?(ZAML::ZAML_ESCAPES)
+
+unless defined?(ZAML::HI_BIT_CHARS)
+  ZAML::HI_BIT_CHARS = '\x80-\xFF'
+  if RUBY_VERSION > "1.9" then ZAML::HI_BIT_CHARS.force_encoding('ASCII-8BIT') ; end
+  ZAML::HI_BIT_CHARS_RE = /([#{ZAML::HI_BIT_CHARS}])/o
+end
+ZAML::EXTENDED_CHARS_RE = /[\x00-\x08\x0B\x0C\x0E-\x1F]/o unless defined?(ZAML::EXTENDED_CHARS_RE)
+
+class String
+  if RUBY_VERSION >= "1.9"
+    def escaped_for_zaml
+      gsub( /\x5C/, "\\\\\\" ).  # Demi-kludge for Maglev/rubinius; the regexp should be /\\/ but parsetree chokes on that.
+        gsub( /"/, "\\\"" ).
+        gsub( /([\x00-\x1F])/ ){|x| ZAML::ZAML_ESCAPES[ x.unpack("C")[0] ] }
+    end
+  else
+    def escaped_for_zaml
+      gsub( /\x5C/, "\\\\\\" ).  # Demi-kludge for Maglev/rubinius; the regexp should be /\\/ but parsetree chokes on that.
+        gsub( /"/, "\\\"" ).
+        gsub( /([\x00-\x1F])/ ){|x| ZAML::ZAML_ESCAPES[ x.unpack("C")[0] ] }.
+        gsub( ZAML::HI_BIT_CHARS_RE ){|x| "\\x#{x.unpack("C")[0].to_s(16)}" }
+    end
+  end
+
+  def classify_for_zaml
+    unless RUBY_VERSION >= "1.9"
+      return :escaped if (self =~ ZAML::HI_BIT_CHARS_RE)
+    end
+    case
+    when self == ''
+      :bare
+    when (self =~ ZAML::EXTENDED_CHARS_RE)
+      :escaped
+    when (
+        (self =~ ZAML::SIMPLE_STRING_RE) or
+        (self =~ /\A\n* /) or
+        (self =~ /[ \r]\s*\z/) or
+        (self =~ /^[>|][-+\d]*\s/i)
+        )
+      :escaped
+    when self =~ /\n/
+      :complex
+    when (
+        (self[-1..-1] =~ /\s/) or
+        (self =~ /[\s:]$/) or
+        (self =~ /[,\[\]\{\}\r\t]|:\s|\s#/) or
+        (self =~ /\A([-:?!#&*'"]|<<|%.+:.)/)
+        )
+      :escaped
+    else
+      :simple
+    end
+  end
+
+  def to_zaml(z=ZAML.new)
+    z.first_time_only(self) {
+      case cl = classify_for_zaml
+      when :bare         then z.emit('""')
+      when :escaped      then z.emit("\"#{escaped_for_zaml}\"")
+      when :simple       then z.emit(self)
+      when :complex
+        lines = split("\n",-1)
+        self =~ /(\s+)\z/
+        if    $1.nil?    then z.emit('|-') ; lastline = ""
+        elsif $1 == "\n" then z.emit('|')  ; lastline = "\n" ; lines.pop
+        else                  z.emit('|+') ; lastline = ""   ; lines.pop ; end
+        z.nested{ lines.each{|line| z.nl; z.emit(line) } }
+        z.emit(lastline)
+        z.nl
+      else raise("Misclassified string: #{cl}!")
+      end
+    }
+  end
+
+  #   z.emit("!binary |") ;
+  #   z.nested{ z.nl; z.emit([self].pack("m72")) }
+end
+
+class Hash
+  def to_zaml(z=ZAML.new)
+    z.first_time_only(self) {
+      z.nested {
+        if empty? then z.emit('{}')
+        else
+          emitted = false
+          each_pair{|k, v|
+            z.no_comment(k){
+              emitted = true
+              z.nl
+              z.prefix_structured_keys('? '){ k.to_zaml(z) }
+              z.vpad(':', k)
+              v.to_zaml(z)
+            }
+          }
+          unless emitted then z.nl ; z.emit('{}') ; end
+        end
+      }
+    }
+  end
+end
+
+
+class Array
+  def to_zaml(z=ZAML.new)
+    z.first_time_only(self) {
+      z.nested {
+        if empty?
+          z.emit('[]')
+        else
+          emitted = false
+          each{|v| z.no_comment(v){
+              emitted = true
+              z.nl('- '); v.to_zaml(z)
+            } }
+          unless emitted then z.nl ; z.emit('[]') ; end
+        end
+      }
+      z.to_s
+    }
+  end
+end
+
+class Time
+  def to_zaml(z=ZAML.new)
+    # 2008-12-06 10:06:51.373758 -07:00
+    ms = ("%0.6f" % (usec * 1e-6)).sub(/^\d+\./,'')
+    offset = "%+0.2i:%0.2i" % [utc_offset / 3600, (utc_offset / 60) % 60]
+    z.emit(self.strftime("%Y-%m-%d %H:%M:%S.#{ms} #{offset}"))
+  end
+end
+
+class Date
+  def to_zaml(z=ZAML.new)
+    z.emit(strftime('%Y-%m-%d'))
+  end
+end
+
+class Range
+  def to_zaml(z=ZAML.new)
+    z.first_time_only(self) {
+      z.emit(zamlized_class_name(Range)+" ")
+      z.nested {
+        z.nl
+        z.emit('begin: ')
+        z.emit(first)
+        z.nl
+        z.emit('end: ')
+        z.emit(last)
+        z.nl
+        z.emit('excl: ')
+        z.emit(exclude_end?)
+      }
+    }
+  end
+end