avro_turf 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9673b4898c8bc5f75fbbdd90b2f4ac3f235c8a07
+  data.tar.gz: 21bb1f430e089ba31e488cd813e5343c961a2325
+SHA512:
+  metadata.gz: 377dcdbd55e9789edc4a38f8324fe0ac2a52f34f06cfdc291a499e67bc4ab6fa9069a5f7fa3a2ff4e057625a5236694832f4c55fd8491bea8558b476c641170e
+  data.tar.gz: 6644b4bcb1cb6b9bf4d3e1030f814897fff44a7b134ad038987b3c52e9f469686055d3416b1b4c144d69010ef3a2576d73625d45e6f366dc3030591c531accc7

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in avro_turf.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Daniel Schierbeck
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,91 @@
+# AvroTurf
+
+AvroTurf is a library that makes it easier to encode and decode data using the [Apache Avro](http://avro.apache.org/) serialization format. It adds a layer on top of the official Avro gem which makes it easier to integrate Avro into your application:
+
+* Provides an idiomatic Ruby interface.
+* Allows referencing schemas defined in another file.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'avro_turf'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install avro_turf
+
+## Usage
+
+Using AvroTurf is quite simple:
+
+```ruby
+# Schemas will be looked up from the specified directory.
+avro = AvroTurf.new(schemas_path: "app/schemas/")
+
+# Decode some data using a named schema. The schema file should exist in the
+# schemas directory with the file name `<name>.avsc`.
+avro.decode(encoded_data, schema_name: "person")
+
+# Encode some data using the named schema.
+avro.encode({ "name" => "Jane", "age" => 28 }, schema_name: "person")
+```
+
+### Inter-schema references
+
+Unlike the official Avro library, AvroTurf allows schemas to reference each other. As an example:
+
+```json
+// person.avsc
+{
+  "name": "person",
+  "type": "record",
+  "fields": [
+    {
+      "name": "full_name",
+      "type": "string"
+    },
+    {
+      "name": "address",
+      "type": "address"
+    }
+  ]
+}
+
+// address.avsc
+{
+  "name": "address",
+  "type": "record",
+  "fields": [
+    {
+      "name": "street",
+      "type": "string"
+    },
+    {
+      "name": "city",
+      "type": "string"
+    }
+  ]
+}
+```
+
+In the example above, the `person` schema references the `address` schema, even though the latter is defined in another file. This makes it possible to share types across schemas, e.g.
+
+```json
+// person_list.avsc
+{
+  "name": "person_list",
+  "type": "array",
+  "items": "person"
+}
+```
+
+There's no reason to copy-paste the `person` schema into the `person_list` schema, as you can reference it directly.
+
+This feature helps avoid subtle errors when the same type is represented using slightly different schemas.

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/avro_turf.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'avro_turf/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "avro_turf"
+  spec.version       = AvroTurf::VERSION
+  spec.authors       = ["Daniel Schierbeck"]
+  spec.email         = ["dasch@zendesk.com"]
+  spec.summary       = "A library that makes it easier to use the Avro serialization format from Ruby"
+  spec.homepage      = "https://github.com/dasch/avro_turf"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "avro", "~> 1.7.7"
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.2.0"
+  spec.add_development_dependency "fakefs"
+end

data/lib/avro_turf.rb

@@ -0,0 +1,67 @@
+require 'avro_turf/version'
+require 'avro'
+
+class AvroTurf
+  def initialize(schemas_path:)
+    @schemas_path = schemas_path
+  end
+
+  # Encodes data to Avro using the specified schema.
+  #
+  # data        - The data that should be encoded.
+  # 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)
+    writer = Avro::IO::DatumWriter.new(schema)
+
+    io = StringIO.new
+    dw = Avro::DataFile::Writer.new(io, writer, schema)
+    dw << data
+    dw.close
+
+    io.string
+  end
+
+  # Decodes Avro data.
+  #
+  # encoded_data - A String containing Avro-encoded data.
+  # schema_name  - The String name of the schema that should be used to read
+  #                the data. If nil, the writer schema will be used.
+  #
+  # Returns whatever is encoded in the data.
+  def decode(encoded_data, schema_name: nil)
+    io = StringIO.new(encoded_data)
+    schema = schema_name && resolve_schema(schema_name)
+    reader = Avro::IO::DatumReader.new(nil, schema)
+    dr = Avro::DataFile::Reader.new(io, reader)
+    dr.first
+  end
+
+  private
+
+  # 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(schema_name, names = {})
+    schema_path = File.join(@schemas_path, schema_name + ".avsc")
+    Avro::Schema.real_parse(JSON.parse(File.read(schema_path)), names)
+  rescue ::Avro::SchemaParseError => e
+    # 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)
+
+      # Re-resolve the original schema now that the dependency has been resolved.
+      names.delete(schema_name)
+      resolve_schema(schema_name, names)
+    else
+      raise
+    end
+  end
+end

data/lib/avro_turf/version.rb

@@ -0,0 +1,3 @@
+class AvroTurf
+  VERSION = "0.0.1"
+end

data/spec/avro_spec.rb

@@ -0,0 +1,128 @@
+require 'fakefs/spec_helpers'
+
+describe AvroTurf do
+  include FakeFS::SpecHelpers
+
+  let(:avro) { AvroTurf.new(schemas_path: "spec/schemas/") }
+
+  before do
+    FileUtils.mkdir_p("spec/schemas")
+  end
+
+  it "encodes and decodes data using a named schema" do
+    schema = <<-AVSC
+      {
+        "name": "person",
+        "type": "record",
+        "fields": [
+          {
+            "type": "string",
+            "name": "full_name"
+          },
+          {
+            "name": "address",
+            "type": {
+              "type": "record",
+              "name": "address",
+              "fields": [
+                {
+                  "type": "string",
+                  "name": "street"
+                },
+                {
+                  "type": "string",
+                  "name": "city"
+                }
+              ]
+            }
+          }
+        ]
+      }
+    AVSC
+
+    FileUtils.mkdir_p("spec/schemas")
+
+    File.open("spec/schemas/person.avsc", "w") do |f|
+      f.write(schema)
+    end
+
+    data = {
+      "full_name" => "John Doe",
+      "address" => {
+        "street" => "Market st. 989",
+        "city" => "San Francisco"
+      }
+    }
+
+    encoded_data = avro.encode(data, schema_name: "person")
+
+    expect(avro.decode(encoded_data, schema_name: "person")).to eq(data)
+  end
+
+  it "resolves named types" do
+    File.open("spec/schemas/person.avsc", "w") do |f|
+      f.write <<-AVSC
+        {
+          "name": "person",
+          "type": "record",
+          "fields": [
+            {
+              "type": "string",
+              "name": "full_name"
+            },
+            {
+              "name": "address",
+              "type": "address"
+            }
+          ]
+        }
+      AVSC
+    end
+
+    File.open("spec/schemas/address.avsc", "w") do |f|
+      f.write <<-AVSC
+        {
+          "type": "record",
+          "name": "address",
+          "fields": [
+            {
+              "type": "string",
+              "name": "street"
+            },
+            {
+              "type": "string",
+              "name": "city"
+            }
+          ]
+        }
+      AVSC
+    end
+
+    data = {
+      "full_name" => "John Doe",
+      "address" => {
+        "street" => "Market st. 989",
+        "city" => "San Francisco"
+      }
+    }
+
+    encoded_data = avro.encode(data, schema_name: "person")
+
+    expect(avro.decode(encoded_data, schema_name: "person")).to eq(data)
+  end
+
+  it "allows decoding without specifying a reader schema" do
+    File.open("spec/schemas/message.avsc", "w") do |f|
+      f.write <<-AVSC
+        {
+          "name": "message",
+          "type": "string"
+        }
+      AVSC
+    end
+
+    encoded_data = avro.encode("hello, world", schema_name: "message")
+
+    expect(avro.decode(encoded_data)).to eq "hello, world"
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+require 'bundler/setup'
+require 'avro_turf'

metadata

@@ -0,0 +1,129 @@
+--- !ruby/object:Gem::Specification
+name: avro_turf
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Daniel Schierbeck
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-03-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: avro
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.7.7
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.7.7
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+- !ruby/object:Gem::Dependency
+  name: fakefs
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- dasch@zendesk.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- avro_turf.gemspec
+- lib/avro_turf.rb
+- lib/avro_turf/version.rb
+- spec/avro_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/dasch/avro_turf
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: A library that makes it easier to use the Avro serialization format from
+  Ruby
+test_files:
+- spec/avro_spec.rb
+- spec/spec_helper.rb
+has_rdoc: