avro_turf 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bc097e71b4fea08649c5e36f5506e2cf46d3b224
-  data.tar.gz: 0da17e13eee520f66bbcf9b4fbee3731a6719787
+  metadata.gz: 64620bcf8c0a04337ecf571abe2d0e51098fce4a
+  data.tar.gz: cc45ee47d74ea7ee364463b105f8cfc92345058b
 SHA512:
-  metadata.gz: de50ca27fa010d2f0f0401398dd2d3eb97c449817cec3ebb0a84d1026a845f082ce2d2e69c7a0241faea1c84c04c1b4d43c1d04bf105ca6e00a8e8aaab0ee779
-  data.tar.gz: 7d10349cd766901ad1b74a74e89931907bb1c6ea17f882ac7d775f0635154fc2427460baed98f4f213e763eeb40d91352da0a247cce67e1646fc147607fd63e6
+  metadata.gz: 090cf294b97ea232c5ec8372eced0244d87f87a6fd3d9cdffdfb2ad73e467e52be0ae1ab3108e53a3e5aabfdd7a3bd2a35aae70c89ca1b448a74305d61d48964
+  data.tar.gz: 657f8b32c84d5b6e01a614bab06a4d17987e3c1832641e62bac8548c139810e60febfc72684983b1342e4839c889b667d037fcbb09932c940366636e32198c5f

data/lib/avro_turf/version.rb

@@ -1,3 +1,3 @@
 class AvroTurf
-  VERSION = "0.1.1"
+  VERSION = "0.2.0"
 end

data/lib/avro_turf.rb

@@ -6,8 +6,10 @@ class AvroTurf
   class Error < StandardError; end
   class SchemaError < Error; end
 
-  def initialize(schemas_path:)
+  def initialize(schemas_path:, namespace: nil)
     @schemas_path = schemas_path or raise "Please specify a schema path"
+    @schemas = Hash.new
+    @namespace = namespace
   end
 
   # Encodes data to Avro using the specified schema.
@@ -16,8 +18,8 @@ class AvroTurf
   # schema_name - The name of a schema in the `schemas_path`.
   #
   # Returns a String containing the encoded data.
-  def encode(data, schema_name:)
-    schema = resolve_schema(schema_name)
+  def encode(data, schema_name:, namespace: @namespace)
+    schema = resolve_schema(schema_name, namespace)
     writer = Avro::IO::DatumWriter.new(schema)
 
     io = StringIO.new
@@ -35,9 +37,9 @@ class AvroTurf
   #                the data. If nil, the writer schema will be used.
   #
   # Returns whatever is encoded in the data.
-  def decode(encoded_data, schema_name: nil)
+  def decode(encoded_data, schema_name: nil, namespace: @namespace)
     io = StringIO.new(encoded_data)
-    schema = schema_name && resolve_schema(schema_name)
+    schema = schema_name && resolve_schema(schema_name, namespace)
     reader = Avro::IO::DatumReader.new(nil, schema)
     dr = Avro::DataFile::Reader.new(io, reader)
     dr.first
@@ -48,15 +50,17 @@ class AvroTurf
   # Resolves and returns a schema.
   #
   # schema_name - The String name of the schema to resolve.
-  # names       - A Hash mapping schema names to Avro::Schema instances. Used
-  #               when referencing custom types.
   #
   # Returns an Avro::Schema.
-  def resolve_schema(fullname, names = {})
+  def resolve_schema(name, namespace = nil)
+    fullname = Avro::Name.make_fullname(name, namespace)
+
+    return @schemas[fullname] if @schemas.key?(fullname)
+
     *namespace, schema_name = fullname.split(".")
     schema_path = File.join(@schemas_path, *namespace, schema_name + ".avsc")
     schema_json = JSON.parse(File.read(schema_path))
-    schema = Avro::Schema.real_parse(schema_json, names)
+    schema = Avro::Schema.real_parse(schema_json, @schemas)
 
     if schema.respond_to?(:fullname) && schema.fullname != fullname
       raise SchemaError, "expected schema `#{schema_path}' to define type `#{fullname}'"
@@ -67,11 +71,11 @@ class AvroTurf
     # This is a hack in order to figure out exactly which type was missing. The
     # Avro gem ought to provide this data directly.
     if e.to_s =~ /"([\w\.]+)" is not a schema we know about/
-      resolve_schema($1, names)
+      resolve_schema($1)
 
       # Re-resolve the original schema now that the dependency has been resolved.
-      names.delete(fullname)
-      resolve_schema(fullname, names)
+      @schemas.delete(fullname)
+      resolve_schema(fullname)
     else
       raise
     end

data/spec/avro_spec.rb

@@ -161,9 +161,9 @@ describe AvroTurf do
       }
     }
 
-    encoded_data = avro.encode(data, schema_name: "test.people.person")
+    encoded_data = avro.encode(data, schema_name: "person", namespace: "test.people")
 
-    expect(avro.decode(encoded_data, schema_name: "test.people.person")).to eq(data)
+    expect(avro.decode(encoded_data, schema_name: "person", namespace: "test.people")).to eq(data)
   end
 
   it "raises AvroTurf::SchemaError if the schema's namespace doesn't match the file location" do
@@ -190,6 +190,35 @@ describe AvroTurf do
     }.to raise_error(AvroTurf::SchemaError, "expected schema `spec/schemas/test/people/person.avsc' to define type `test.people.person'")
   end
 
+  it "caches schemas in memory" do
+    define_schema "person.avsc", <<-AVSC
+      {
+        "name": "person",
+        "type": "record",
+        "fields": [
+          {
+            "type": "string",
+            "name": "full_name"
+          }
+        ]
+      }
+    AVSC
+
+    data = {
+      "full_name" => "John Doe"
+    }
+
+    # Warm the schema cache.
+    avro.encode(data, schema_name: "person")
+
+    # Force a failure if the schema file is read again.
+    FileUtils.rm("spec/schemas/person.avsc")
+
+    encoded_data = avro.encode(data, schema_name: "person")
+
+    expect(avro.decode(encoded_data, schema_name: "person")).to eq(data)
+  end
+
   def define_schema(path, content)
     File.open(File.join("spec/schemas", path), "w") do |f|
       f.write(content)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: avro_turf
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Daniel Schierbeck
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-06 00:00:00.000000000 Z
+date: 2015-03-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: avro