schemata-staging 0.0.1.1 → 0.0.3.beta2

data/lib/schemata/common/componentbase.rb

@@ -0,0 +1,42 @@
+require 'schemata/helpers/decamelize'
+
+module Schemata
+  module ComponentBase
+
+    def message_types
+      self.constants.select { |x| x != :VERSION }
+    end
+
+    def component_name
+      self.name.split("::")[1]
+    end
+
+    def eigenclass
+      class << self; self; end
+    end
+
+    def register_mock_methods
+      message_types.each do |type|
+        message_type = self::const_get(type)
+        mock_method_name = "mock_#{Schemata::Helpers.decamelize(type.to_s)}"
+        eigenclass.send(:define_method, mock_method_name) do |*args|
+          version = args[0] || message_type.current_version
+          message_type::const_get("V#{version}").mock
+        end
+      end
+    end
+
+    def require_message_classes
+      path = "./lib/schemata/"
+      path << Schemata::Helpers.decamelize(component_name)
+      path << "/*.rb"
+      Dir.glob(path, &method(:require))
+    end
+
+    def self.extended(klass)
+      klass.require_message_classes
+      klass.register_mock_methods
+    end
+
+  end
+end

data/lib/schemata/common/error.rb

@@ -1,12 +1,18 @@
 module Schemata
   class DecodeError < StandardError; end
   class EncodeError < StandardError; end
-  class UpdateAttributeError < StandardError; end
+  class SchemaDefinitionError < StandardError; end
+
+  class UpdateAttributeError < StandardError
+    def initialize(key, message)
+      super("#{key}: #{message}")
+    end
+  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

@@ -1,5 +1,8 @@
 require 'yajl'
+require 'membrane'
 require 'schemata/common/error'
+require 'schemata/helpers/stringify'
+require 'membrane'
 
 module Schemata
   module MessageBase
@@ -11,16 +14,28 @@ module Schemata
         @contents = {}
 
         data.each do |key, field_value|
+          key = Schemata::Helpers.stringify(key)
           field_schema = @schema.schemas[key]
           next unless field_schema
 
+          # TODO This call to stringify should be removed when cc/dea stop using
+          # Symbols.
+          #
+          # Currently, some fields (for example, 'states' in requests sent
+          # on dea.find.droplet), are are symbols, During Yajl decoding, however,
+          # they become strings. Thus, on the encoding side, Schemata should expect
+          # symbols, but on the decoding side, it should expect strings. To allow
+          # for this in the schema definition, Schemata stringifies all symbols during
+          # construction of Schemata objects.
+          field_value = Schemata::Helpers.stringify(field_value)
+
           begin
             field_schema.validate(field_value)
           rescue Membrane::SchemaValidationError => e
-            raise Schemata::UpdateAttributeError.new(e.message)
+            raise Schemata::UpdateAttributeError.new(key, e.message)
           end
 
-          @contents[key] = Schemata::HashCopyHelpers.deep_copy(field_value)
+          @contents[key] = Schemata::Helpers.deep_copy(field_value)
         end
       end
 
@@ -29,19 +44,24 @@ module Schemata
         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])
+            unless @contents[key].nil?
+              return Schemata::Helpers.deep_copy(@contents[key])
             end
             nil
           end
 
+          # TODO This call to stringify should be removed when cc/dea stops using
+          # symbols. See comment above for a better description.
           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)
+            field_value = Schemata::Helpers.stringify(field_value)
+            unless schema.optional_keys.include?(key) && field_value == nil
+              begin
+                field_schema.validate(field_value)
+              rescue Membrane::SchemaValidationError => e
+                raise Schemata::UpdateAttributeError.new(key, e.message)
+              end
             end
-            @contents[key] = Schemata::HashCopyHelpers.deep_copy(field_value)
+            @contents[key] = Schemata::Helpers.deep_copy(field_value)
             field_value
           end
         end
@@ -49,7 +69,7 @@ module Schemata
       end
 
       def contents
-        Schemata::HashCopyHelpers.deep_copy(@contents)
+        Schemata::Helpers.deep_copy(@contents)
       end
 
       def empty?
@@ -130,6 +150,11 @@ module Schemata
       Schemata::const_get(component)::const_get(msg_type)
     end
 
+    def component
+      _, component, msg_type, version = self.class.name.split("::")
+      Schemata::const_get(component)
+    end
+
     def self.included(klass)
       klass.extend(Schemata::ClassMethods)
       klass.extend(Dsl)

data/lib/schemata/common/msgtypebase.rb

@@ -1,5 +1,6 @@
 require 'schemata/common/msgbase'
 require 'schemata/common/parsed_msg'
+require 'schemata/helpers/decamelize'
 
 module Schemata
   module MessageTypeBase
@@ -19,10 +20,14 @@ module Schemata
 
     def decode(json_msg)
       begin
-        parsed = Schemata::ParsedMessage.new(json_msg)
+        if versions.size == 2
+          parsed = Schemata::ParsedMessage.new(cleanup(json_msg))
+        else
+          parsed = Schemata::ParsedMessage.new(json_msg)
+        end
       rescue Schemata::DecodeError => e
-        raise e unless versions.size == 1
-        return decode_raw_payload(json_msg)
+        return decode_raw_payload(json_msg) if versions.size == 1
+        raise e
       end
       message_version = parsed.version
 
@@ -61,8 +66,32 @@ module Schemata
       end
     end
 
+    def component
+      _, component, message_type = self.name.split("::")
+      Schemata::const_get(component)
+    end
+
+    def component_name
+      self.name.split("::")[1]
+    end
+
+    def message_type_name
+      self.name.split("::")[2]
+    end
+
+    def require_message_versions
+      path = "./lib/schemata/"
+      path << Schemata::Helpers.decamelize(component_name)
+      path << "/"
+      path << Schemata::Helpers.decamelize(message_type_name)
+      path << "/*.rb"
+
+      Dir.glob(path, &method(:require))
+    end
+
     def self.extended(o)
       o.extend Dsl
+      o.require_message_versions
     end
 
     module Dsl
@@ -118,5 +147,18 @@ module Schemata
       end
     end
 
+    def cleanup(json)
+      msg_contents = Yajl::Parser.parse(json)
+      clean_msg = {}
+
+      msg_contents.keys.each do |key|
+        if key == "min_version" || key =~ /^V[0-9]+$/
+          clean_msg[key] = msg_contents[key]
+        end
+      end
+
+      Yajl::Encoder.encode(clean_msg)
+    end
+
   end
 end

data/lib/schemata/common/parsed_msg.rb

@@ -37,7 +37,7 @@ module Schemata
     end
 
     def contents
-      Schemata::HashCopyHelpers.deep_copy(@contents)
+      Schemata::Helpers.deep_copy(@contents)
     end
   end
 end

data/lib/schemata/helpers/decamelize.rb

@@ -0,0 +1,23 @@
+module Schemata
+  module Helpers
+    def self.decamelize(str)
+      words = []
+      curr_word = ""
+      0.upto(str.length - 1) do |i|
+        ch = str[i]
+        if ch =~ /[A-Z]/
+          words.push(curr_word)
+          curr_word = ""
+        end
+        curr_word += ch
+      end
+      words.push(curr_word)
+      words.map! { |x| x.downcase }
+
+      # If the first letter is capitalized, then the first word here is empty
+      words.shift if words[0] == ""
+
+      words.join('_')
+    end
+  end
+end

data/lib/schemata/helpers/hash_copy.rb

@@ -1,5 +1,5 @@
 module Schemata
-  module HashCopyHelpers
+  module Helpers
     class CopyError < StandardError; end
 
     def self.deep_copy(node)

data/lib/schemata/helpers/stringify.rb

@@ -0,0 +1,26 @@
+module Schemata
+  module Helpers
+
+    def self.stringify(node)
+      case node
+      when String
+        return node
+      when Numeric, TrueClass, FalseClass
+        return node
+      when Hash
+        copy = {}
+        node.each { |k, v| copy[k.to_s] = stringify(v) }
+        return copy
+      when Array
+        return node.map { |v| stringify(v) }
+      when NilClass
+        return nil
+      when Symbol
+        return node.to_s
+      else
+        raise CopyError.new("Unexpected class: #{node.class}")
+      end
+    end
+
+  end
+end

data/lib/schemata/staging/message/message_v1.rb

@@ -30,7 +30,7 @@ module Schemata
                 },
                 "options"               => any,
                 "plan"                  => String,
-                "plan_option"          => any,
+                "plan_option"          => enum(String, NilClass),
                 "type"                  => String,
                 "version"               => String,
                 "vendor"                => String,

data/lib/schemata/staging/message/message_v2.rb

@@ -0,0 +1,148 @@
+require 'membrane'
+require 'schemata/helpers/hash_copy'
+require 'schemata/common/msgtypebase'
+
+module Schemata
+  module Staging
+    module Message
+
+      version 2 do
+        define_schema do
+          {
+            "app_id"                    => Integer,
+            "download_uri"              => String,
+            "upload_uri"                 => String,
+            "properties" => {
+              "services" => [ {
+                "label"                 => String,
+                "tags"                  => [String],
+                "name"                  => String,
+                "credentials" => {
+                  # XXX Does this schema vary by service?
+                  "hostname"            => String,
+                  "host"                => String,
+                  "port"                => Integer,
+                  "password"            => String,
+                  "name"                => String,
+
+                },
+                "options"               => any,
+                "plan"                  => String,
+                "plan_option"          => enum(String, NilClass),
+                "type"                  => String,
+                "version"               => String,
+                "vendor"                => String,
+              } ],
+              "environment"             => [String],
+              "framework"               => String,
+              "framework_info" => {
+                "name"                  => String,
+                optional("detection")   => [Hash],
+                optional("runtimes")    => [Hash],
+              },
+              "meta" => {
+                optional("debug")       => any,
+                optional("console")     => any,
+                optional("command")     => String,
+              },
+              "resources" => {
+                "memory"                => Integer,
+                "disk"                  => Integer,
+                "fds"                   => Integer,
+              },
+              "runtime"                 => String,
+              "runtime_info"            => Hash,
+            },
+          }
+        end
+
+        define_min_version 1
+
+        define_upvert do |old_data|
+          old_data
+        end
+
+        define_generate_old_fields do |msg_obj|
+          {}
+        end
+
+        define_mock_values do
+          {
+          "app_id"                => 1,
+          "download_uri"          => "http://foobar@172.0.0.0:100/download",
+          "upload_uri"            => "http://foobar@172.0.0.0:100/upload",
+          "properties" => {
+            "services" => [ {
+              "label"             => "mongodb-1.8",
+              "tags"              => ["mongodb"],
+              "name"              => "mongodb-685a",
+              "credentials" => {
+                "hostname"        => "172.20.208.40",
+                "host"            => "172.20.208.40",
+                "port"            => 25001,
+                "password"        => "a2ee7245-cdee-4a4a-b426-a8258ff1b39a",
+                "name"            => "2eaa7336-2696-43cd-bb96-a614740b3511",
+                "username"        => "aaf31edf-b2bc-4f97-a033-7021c2528ce8",
+                "db"              => "db",
+                "url"             => "mongodb://aaf31edf-b2bc-4f97-a033-7021c2528ce8:a2ee7245-cdee-4a4a-b426-a8258ff1b39a@172.20.208.40:25001/db",
+              },
+              "options"           => {},
+              "plan"              => "free",
+              "plan_option"      => nil,
+              "type"              => "document",
+              "version"           => "1.8",
+              "vendor"            => "mongodb",
+            } ],
+            "environment"         => [],
+            "framework"           => "sinatra",
+            "framework_info" => {
+              "name"              => "sinatra",
+              "runtimes" => [
+                {"ruby18" => {
+                  "default"       => true}},
+                {"ruby19" => {
+                  "default"       => false}},
+              ],
+              "detection" => [
+                {"*.rb"           => "\\s*require[\\s\\(]*['\"]sinatra(/base)?['\"]"},
+                {"config/environment.rb" => false}
+              ],
+            },
+            "meta" => {
+              "debug"             => nil,
+              "console"           => nil,
+            },
+            "resources" => {
+              "memory"            => 64,
+              "disk"              => 2048,
+              "fds"               => 256,
+            },
+            "runtime"             => "ruby19",
+            "runtime_info" => {
+              "description"       => "Ruby 1.9",
+              "version"           => "1.9.2p180",
+              "executable"        => "/var/vcap/packages/dea_ruby19/bin/ruby",
+              "staging"           => "/var/vcap/packages/ruby/bin/ruby stage",
+              "version_output"    => "1.9.2",
+              "version_flag"      => "-e 'puts RUBY_VERSION'",
+              "additional_checks" => "-e 'puts RUBY_PATCHLEVEL == 180'",
+              "environment" => {
+                "LD_LIBRARY_PATH" => "/var/vcap/packages/mysqlclient/lib/mysql:/var/vcap/packages/sqlite/lib:/var/vcap/packages/libpq/lib:/var/vcap/packages/imagemagick/lib:$LD_LIBRARY_PATH",
+                "BUNDLE_GEMFILE"  => nil,
+                "PATH"            => "/var/vcap/packages/imagemagick/bin:/var/vcap/packages/dea_transition/rubygems/1.9.1/bin:/var/vcap/packages/dea_ruby19/bin:/var/vcap/packages/dea_node08/bin:$PATH",
+                "GEM_PATH"        => "/var/vcap/packages/dea_transition/rubygems/1.9.1:$GEM_PATH",
+              },
+              "status" => {
+                "name"            => "current",
+              },
+              "series"            => "ruby19",
+              "category"          => "ruby",
+              "name"              => "ruby19",
+            }
+          }
+        }
+        end
+      end
+    end
+  end
+end

data/lib/schemata/staging/message.rb

@@ -7,7 +7,3 @@ module Schemata
     end
   end
 end
-
-Dir[File.dirname(__FILE__) + '/message/*.rb'].each do |file|
-  require file
-end

data/lib/schemata/staging/version.rb

@@ -1,5 +1,5 @@
 module Schemata
   module Staging
-    VERSION = "0.0.1.1"
+    VERSION = "0.0.3.beta2"
   end
 end

data/lib/schemata/staging.rb

@@ -1,9 +1,7 @@
-require 'schemata/staging/message'
+require 'schemata/common/componentbase'
 
 module Schemata
   module Staging
-    def self.mock_message(version=Message.current_version)
-      Message::const_get("V#{version}").mock
-    end
+    extend Schemata::ComponentBase
   end
 end

data/spec/cloud_controller_spec.rb

@@ -0,0 +1,6 @@
+require 'schemata/cloud_controller'
+require 'spec_helper'
+
+describe Schemata::CloudController do
+  it_behaves_like "a schemata component"
+end

data/spec/common/helpers_spec.rb

@@ -1,48 +1,49 @@
 require 'schemata/helpers/hash_copy'
+require 'schemata/helpers/stringify'
 
-describe Schemata::HashCopyHelpers do
+describe Schemata::Helpers do
   describe "#deep_copy" do
     it "should deep copy nil" do
-      copy = Schemata::HashCopyHelpers.deep_copy(nil)
+      copy = Schemata::Helpers.deep_copy(nil)
       copy.should == nil
     end
 
     it "should deep copy a given string" do
       original = "foo"
-      copy = Schemata::HashCopyHelpers.deep_copy(original)
+      copy = Schemata::Helpers.deep_copy(original)
       copy.should be_instance_of String
       copy.should == original
       copy.object_id.should_not == original.object_id
     end
 
     it "should deep copy a given boolean" do
-      Schemata::HashCopyHelpers.deep_copy(true).
+      Schemata::Helpers.deep_copy(true).
         should be_an_instance_of TrueClass
-      Schemata::HashCopyHelpers.deep_copy(false).
+      Schemata::Helpers.deep_copy(false).
         should be_an_instance_of FalseClass
     end
 
     it "should deep copy a given numeric type" do
       original = 0
-      copy = Schemata::HashCopyHelpers.deep_copy(original)
+      copy = Schemata::Helpers.deep_copy(original)
       copy.should == original
       copy.should be_an_instance_of Fixnum
 
       # set original to be max fixnum + 1
-      original = 2**(0.size * 8 -2)
-      copy = Schemata::HashCopyHelpers.deep_copy(original)
+      original = 2**(0.size * 8 - 2)
+      copy = Schemata::Helpers.deep_copy(original)
       copy.should == original
       copy.should be_an_instance_of Bignum
 
       original = 0.0
-      copy = Schemata::HashCopyHelpers.deep_copy(original)
+      copy = Schemata::Helpers.deep_copy(original)
       copy.should == original
       copy.should be_an_instance_of Float
     end
 
     it "should deep copy a given hash" do
       original = {"foo" => "bar"}
-      copy = Schemata::HashCopyHelpers.deep_copy(original)
+      copy = Schemata::Helpers.deep_copy(original)
       copy.should be_instance_of Hash
       copy.should == original
 
@@ -52,7 +53,7 @@ describe Schemata::HashCopyHelpers do
 
     it "should deep copy a given array" do
       original = [1, 2, "hello"]
-      copy = Schemata::HashCopyHelpers.deep_copy(original)
+      copy = Schemata::Helpers.deep_copy(original)
       copy.should be_instance_of Array
       copy.should == original
 
@@ -68,7 +69,7 @@ describe Schemata::HashCopyHelpers do
           "hello" => "goodbye",
         },
       }
-      copy = Schemata::HashCopyHelpers.deep_copy(original)
+      copy = Schemata::Helpers.deep_copy(original)
       copy.should be_instance_of Hash
       copy.should == original
 
@@ -82,8 +83,33 @@ describe Schemata::HashCopyHelpers do
     it "should raise error for unknown type" do
       klass = Class.new
       expect do
-        Schemata::HashCopyHelpers.deep_copy(klass.new)
+        Schemata::Helpers.deep_copy(klass.new)
       end.to raise_error(described_class::CopyError, /Unexpected class: /)
     end
   end
+
+  describe "#stringify" do
+    it "should stringify nil" do
+      str = Schemata::Helpers.stringify(nil)
+      str.should == nil
+    end
+
+    it "should stringify a string" do
+      original = "foo"
+      str = Schemata::Helpers.stringify(original)
+      str.should == "foo"
+    end
+
+    it "should stringify a symbol" do
+      original = :foo
+      str = Schemata::Helpers.stringify(original)
+      str.should == "foo"
+    end
+
+    it "should stringify a hash" do
+      original = { "foo" => :foo }
+      str = Schemata::Helpers.stringify(original)
+      str.should == { "foo" => "foo" }
+    end
+  end
 end