lib/membrane/schema_parser.rb in membrane-0.0.2 vs lib/membrane/schema_parser.rb in membrane-0.0.4

@@ -1,6 +1,6 @@
-require "membrane/schema"
+require "membrane/schemas"
 
 module Membrane
 end
 
 class Membrane::SchemaParser
@@ -11,15 +11,15 @@
     DictionaryMarker  = Struct.new(:key_schema, :value_schema)
     EnumMarker        = Struct.new(:elem_schemas)
     TupleMarker       = Struct.new(:elem_schemas)
 
     def any
-      Membrane::Schema::Any.new
+      Membrane::Schemas::Any.new
     end
 
     def bool
-      Membrane::Schema::Bool.new
+      Membrane::Schemas::Bool.new
     end
 
     def enum(*elem_schemas)
       EnumMarker.new(elem_schemas)
     end
@@ -51,35 +51,35 @@
     do_parse(intermediate_schema)
   end
 
   def deparse(schema)
     case schema
-    when Membrane::Schema::Any
+    when Membrane::Schemas::Any
       "any"
-    when Membrane::Schema::Bool
+    when Membrane::Schemas::Bool
       "bool"
-    when Membrane::Schema::Class
+    when Membrane::Schemas::Class
       schema.klass.name
-    when Membrane::Schema::Dictionary
+    when Membrane::Schemas::Dictionary
       "dict(%s, %s)" % [deparse(schema.key_schema),
                         deparse(schema.value_schema)]
-    when Membrane::Schema::Enum
+    when Membrane::Schemas::Enum
       "enum(%s)" % [schema.elem_schemas.map { |es| deparse(es) }.join(", ")]
-    when Membrane::Schema::List
+    when Membrane::Schemas::List
       "[%s]" % [deparse(schema.elem_schema)]
-    when Membrane::Schema::Record
+    when Membrane::Schemas::Record
       deparse_record(schema)
-    when Membrane::Schema::Regexp
+    when Membrane::Schemas::Regexp
       schema.regexp.inspect
-    when Membrane::Schema::Tuple
+    when Membrane::Schemas::Tuple
       "tuple(%s)" % [schema.elem_schemas.map { |es| deparse(es) }.join(", ")]
-    when Membrane::Schema::Value
+    when Membrane::Schemas::Value
       schema.value.inspect
-    when Membrane::Schema::Base
+    when Membrane::Schemas::Base
       schema.inspect
     else
-      emsg = "Expected instance of Membrane::Schema::Base, given instance of" \
+      emsg = "Expected instance of Membrane::Schemas::Base, given instance of" \
              + " #{schema.class}"
       raise ArgumentError.new(emsg)
     end
   end
 
@@ -90,37 +90,37 @@
     when Hash
       parse_record(object)
     when Array
       parse_list(object)
     when Class
-      Membrane::Schema::Class.new(object)
+      Membrane::Schemas::Class.new(object)
     when Regexp
-      Membrane::Schema::Regexp.new(object)
+      Membrane::Schemas::Regexp.new(object)
     when Dsl::DictionaryMarker
-      Membrane::Schema::Dictionary.new(do_parse(object.key_schema),
+      Membrane::Schemas::Dictionary.new(do_parse(object.key_schema),
                                        do_parse(object.value_schema))
     when Dsl::EnumMarker
       elem_schemas = object.elem_schemas.map { |s| do_parse(s) }
-      Membrane::Schema::Enum.new(*elem_schemas)
+      Membrane::Schemas::Enum.new(*elem_schemas)
     when Dsl::TupleMarker
       elem_schemas = object.elem_schemas.map { |s| do_parse(s) }
-      Membrane::Schema::Tuple.new(*elem_schemas)
-    when Membrane::Schema::Base
+      Membrane::Schemas::Tuple.new(*elem_schemas)
+    when Membrane::Schemas::Base
       object
     else
-      Membrane::Schema::Value.new(object)
+      Membrane::Schemas::Value.new(object)
     end
   end
 
   def parse_list(schema)
     if schema.empty?
       raise ArgumentError.new("You must supply a schema for elements.")
     elsif schema.length > 1
       raise ArgumentError.new("Lists can only match a single schema.")
     end
 
-    Membrane::Schema::List.new(do_parse(schema[0]))
+    Membrane::Schemas::List.new(do_parse(schema[0]))
   end
 
   def parse_record(schema)
     if schema.empty?
       raise ArgumentError.new("You must supply at least one key-value pair.")
@@ -137,11 +137,11 @@
       end
 
       parsed[key] = do_parse(value_schema)
     end
 
-    Membrane::Schema::Record.new(parsed, optional_keys)
+    Membrane::Schemas::Record.new(parsed, optional_keys)
   end
 
   def deparse_record(schema)
     lines = ["{"]
 
@@ -151,9 +151,10 @@
         dep_key = "optional(%s)" % [key.inspect]
       else
         dep_key = key.inspect
       end
 
+      dep_key = DEPARSE_INDENT + dep_key
       dep_val_schema_lines = deparse(val_schema).split("\n")
 
       dep_val_schema_lines.each_with_index do |line, line_idx|
         to_append = nil