stark 0.5.0

data/test/test_parser.rb

@@ -0,0 +1,278 @@
+require 'test/unit'
+require 'stark/parser'
+
+class TestParser < Test::Unit::TestCase
+  def parse(data)
+    tg = Stark::Parser.new data
+
+    unless tg.parse
+      tg.raise_error
+    end
+
+    assert tg.result
+  end
+
+  def test_ccomment
+    parse "/* blah */\n"
+    parse "/* blah */ /* foo */\n"
+  end
+
+  def test_hcomment
+    parse "# blah\n"
+  end
+
+  def test_const_value_in_struct
+    parse <<-EOM
+struct Hello {
+  1: string greeting = "hello world"
+}
+    EOM
+  end
+
+  def test_enum
+    parse <<-EOM
+enum SomeEnum {
+  ONE
+  TWO
+}
+    EOM
+  end
+
+  def test_list
+    parse <<-EOM
+struct Foo {
+  1: list<i32> ints
+}
+    EOM
+  end
+
+  def test_list_with_value
+    parse <<-EOM
+struct Foo {
+  1: list<i32> ints = [1, 2, 2, 3],
+}
+    EOM
+  end
+
+  include Stark::Parser::AST
+
+  def comment(text)
+    Comment.new(text)
+  end
+  def field(index, type, name)
+    Field.new(index, type, name)
+  end
+  def function(name, return_type, arguments)
+    Function.new(name, return_type, arguments)
+  end
+  def include(path)
+    Include.new(path)
+  end
+  def namespace(lang, namespace)
+    Namespace.new(lang, namespace)
+  end
+  def service(name, functions)
+    Service.new(name, functions)
+  end
+  def struct(name, fields)
+    Struct.new(name, fields)
+  end
+
+  def list(t)
+    List.new(t)
+  end
+
+  def map(a,b)
+    Map.new(a,b)
+  end
+
+  def set(a)
+    Set.new(a)
+  end
+
+  def assert_type(exc, acc)
+    case exc
+    when List, Set
+      assert_type exc.value, acc.value
+    when Map
+      assert_type exc.key, acc.key
+      assert_type exc.value, acc.value
+    else
+      assert_equal exc, acc
+    end
+  end
+
+  def assert_field(f, idx, type, name)
+    assert_equal idx, f.index
+    assert_equal name, f.name
+    assert_type type, f.type
+  end
+
+  def assert_func(f, ret_type, name, args)
+    assert_type ret_type, f.return_type
+    assert_equal name, f.name
+
+    return if !args and !f.arguments
+
+    args.zip(f.arguments).each do |exc, arg|
+      assert_equal exc[0], arg.index
+      assert_type exc[1], arg.type
+      assert_equal exc[2], arg.name
+    end
+  end
+
+  def test_spec
+    data = File.read "test/ThriftSpec.thrift"
+
+    tg = Stark::Parser.new data
+
+    unless tg.parse
+      tg.raise_error
+    end
+
+    ary = tg.result
+
+    comments = ary.shift(19)
+    comments.each { |c| assert_kind_of Comment, c }
+
+    ns = ary.shift
+
+    assert_equal "rb", ns.lang
+    assert_equal "SpecNamespace", ns.namespace
+
+    ns = ary.shift
+
+    assert_equal "Hello", ns.name
+    assert_equal 1, ns.fields.size
+    f = ns.fields[0]
+
+    assert_equal 1, f.index
+    assert_equal "string", f.type
+    assert_equal "greeting", f.name
+
+    assert_equal "hello world", f.value.value
+
+    e = ary.shift
+
+    assert_equal ["ONE", "TWO"], e.values
+
+    s = ary.shift
+
+    assert_equal "StructWithSomeEnum", s.name
+    assert_equal 1, s.fields.size
+    f = s.fields.first
+
+    assert_equal 1, f.index
+    assert_equal "SomeEnum", f.type
+    assert_equal "some_enum", f.name
+
+    s = ary.shift
+    assert_equal :union, s.type
+    assert_equal "TestUnion", s.name
+    assert_equal 5, s.fields.size
+
+    fs = s.fields
+
+    assert_field fs[0], 1, "string", "string_field"
+    assert_field fs[1], 2, "i32", "i32_field"
+    assert_field fs[2], 3, "i32", "other_i32_field"
+    assert_field fs[3], 4, "SomeEnum", "enum_field"
+    assert_field fs[4], 5, "binary", "binary_field"
+
+    s = ary.shift
+    assert_equal "Foo", s.name
+    assert_equal 8, s.fields.size
+
+    f = s.fields
+
+    assert_field f[0], 1, "i32", "simple"
+    assert_field f[1], 2, "string", "words"
+    assert_equal "words", f[1].value.value
+
+    assert_field f[2], 3, "Hello", "hello"
+    assert_equal "greeting", f[2].value.values[0][0].value
+    assert_equal "hello, world!", f[2].value.values[0][1].value
+
+    assert_field f[3], 4, list("i32"), "ints"
+    ints = f[3].value.values.map { |i| i.value }
+    assert_equal [1, 2, 2, 3], ints
+
+    assert_field f[4], 5, map("i32", map("string", "double")), "complex"
+
+    assert_field f[5], 6, set("i16"), "shorts"
+    ints = f[5].value.values.map { |i| i.value }
+    assert_equal [5, 17, 239], ints
+
+    assert_field f[6], 7, "string", "opt_string"
+    assert_field f[7], 8, "bool", "my_bool"
+
+    assert_equal ["optional"], f[6].options
+
+    s = ary.shift
+
+    assert_equal "Foo2", s.name
+    assert_equal 1, s.fields.size
+
+    assert_field s.fields[0], 1, "binary", "my_binary"
+
+    s = ary.shift
+    assert_equal "BoolStruct", s.name
+    assert_equal 1, s.fields.size
+
+    assert_field s.fields[0], 1, "bool", "yesno"
+    assert_equal 1, s.fields[0].value.value
+
+    s = ary.shift
+    fs = s.fields
+
+    assert_field fs[0], 1, list("bool"), "bools"
+    assert_field fs[1], 2, list("byte"), "bytes"
+    assert_field fs[2], 3, list("i16"), "i16s"
+    assert_field fs[3], 4, list("i32"), "i32s"
+    assert_field fs[4], 5, list("i64"), "i64s"
+    assert_field fs[5], 6, list("double"), "doubles"
+    assert_field fs[6], 7, list("string"), "strings"
+    assert_field fs[7], 8, list(map("i16", "i16")), "maps"
+    assert_field fs[8], 9, list(list("i16")), "lists"
+    assert_field fs[9], 10, list(set("i16")), "sets"
+    assert_field fs[10], 11, list("Hello"), "hellos"
+
+    s = ary.shift
+    assert_equal "Xception", s.name
+    assert_field s.fields[0], 1, "string", "message"
+    assert_field s.fields[1], 2, "i32", "code"
+    assert_equal 1, s.fields[1].value.value
+
+    s = ary.shift
+    assert_equal "NonblockingService", s.name
+    fs = s.functions
+
+    assert_func fs[0], "Hello", "greeting", [[1, "bool", "english"]]
+    assert_func fs[1], "bool", "block", nil
+    assert_func fs[2], "void", "unblock", [[1, "i32", "n"]]
+    assert_func fs[3], "void", "shutdown", nil
+    assert_func fs[4], "void", "sleep", [[1, "double", "seconds"]]
+
+    s = ary.shift
+    assert_equal "My_union", s.name
+    fs = s.fields
+    assert_field fs[0], 1, "bool", "im_true"
+    assert_field fs[1], 2, "byte", "a_bite"
+    assert_field fs[2], 3, "i16", "integer16"
+    assert_field fs[3], 4, "i32", "integer32"
+    assert_field fs[4], 5, "i64", "integer64"
+    assert_field fs[5], 6, "double", "double_precision"
+    assert_field fs[6], 7, "string", "some_characters"
+    assert_field fs[7], 8, "i32", "other_i32"
+    assert_field fs[8], 9, "SomeEnum", "some_enum"
+    assert_field fs[9], 10, map("SomeEnum", list("SomeEnum")), "my_map"
+
+    s = ary.shift
+    assert_equal "Struct_with_union", s.name
+    fs = s.fields
+
+    assert_field fs[0], 1, "My_union", "fun_union"
+    assert_field fs[1], 2, "i32", "integer32"
+    assert_field fs[2], 3, "string", "some_characters"
+  end
+end

data/test/test_server.rb

@@ -0,0 +1,175 @@
+require 'test/unit'
+
+require 'stark'
+
+require 'rubygems'
+require 'thrift'
+
+Thread.abort_on_exception = true
+
+class TestServer < Test::Unit::TestCase
+  def setup
+    @client_t, @server_t = Stark.pipe_transport
+    @client_p = Thrift::BinaryProtocol.new @client_t
+    @server_p = Thrift::BinaryProtocol.new @server_t
+
+    @n = Module.new
+    Stark.materialize "test/profile.thrift", @n
+
+    @client = @n::UserStorage::Client.new @client_p, @client_p
+    @handler = Handler.new
+    @server = @n::UserStorage::Processor.new @handler
+  end
+
+  def teardown
+    @client_t.close
+    @server_t.close
+  end
+
+  class Handler
+    def initialize
+      @users = {}
+      @last_map = nil
+      @last_list = nil
+      @last_status = nil
+    end
+
+    attr_accessor :last_map, :last_list, :last_status
+
+    def store(obj)
+      @users[obj.uid] = obj
+    end
+
+    def retrieve(id)
+      @users[id]
+    end
+
+    def set_map(m)
+      @last_map = m
+    end
+
+    def set_list(l)
+      @last_list = l
+    end
+
+    def set_status(s)
+      @last_status = s
+    end
+  end
+
+  def test_store_and_retrieve
+    st = Thread.new do
+      @server.process @server_p, @server_p
+    end
+
+    xuser = @n::UserProfile.new 'uid' => 0, 'name' => 'root', 'blurb' => 'god'
+
+    @client.store xuser
+
+    st.join
+
+    st = Thread.new do
+      @server.process @server_p, @server_p
+    end
+
+    obj = @client.retrieve 0
+
+    st.join
+
+    assert_equal 0, obj.uid
+    assert_equal "root", obj.name
+    assert_equal "god", obj.blurb
+  end
+
+  def test_set_map
+    st = Thread.new do
+      @server.process @server_p, @server_p
+    end
+
+    m = { "blah" => "foo", "a" => "b" }
+
+    @client.set_map m
+
+    st.join
+
+    assert_equal "foo", @handler.last_map["blah"]
+    assert_equal "b", @handler.last_map["a"]
+  end
+
+  def test_last_map
+    st = Thread.new do
+      @server.process @server_p, @server_p
+    end
+
+    @handler.last_map = { "blah" => "foo", "a" => "b" }
+
+    m = @client.last_map
+
+    st.join
+
+    assert_equal "foo", m["blah"]
+    assert_equal "b", m["a"]
+  end
+
+  def test_set_list
+    st = Thread.new do
+      @server.process @server_p, @server_p
+    end
+
+    m = [ "blah", "foo", "a", "b" ]
+
+    @client.set_list m
+
+    st.join
+
+    assert_equal m, @handler.last_list
+  end
+
+  def test_last_list
+    st = Thread.new do
+      @server.process @server_p, @server_p
+    end
+
+    l = [ "blah", "foo", "a", "b" ]
+    @handler.last_list = l
+
+    assert_equal l, @client.last_list
+
+    st.join
+  end
+
+  def test_last_list_is_nil
+    st = Thread.new do
+      @server.process @server_p, @server_p
+    end
+
+    assert_equal [], @client.last_list
+
+    st.join
+  end
+
+  def test_enum
+    st = Thread.new do
+      @server.process @server_p, @server_p
+    end
+
+    @client.set_status :ON
+
+    st.join
+
+    assert_equal :ON, @handler.last_status
+  end
+
+  def test_enum_recv
+    st = Thread.new do
+      @server.process @server_p, @server_p
+    end
+
+    @handler.last_status = :ON
+
+    assert_equal :ON, @client.last_status
+
+    st.join
+  end
+
+end

metadata

@@ -0,0 +1,134 @@
+--- !ruby/object:Gem::Specification
+name: stark
+version: !ruby/object:Gem::Version
+  version: 0.5.0
+  prerelease: 
+platform: ruby
+authors:
+- Evan Phoenix
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-02-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thrift
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.10'
+- !ruby/object:Gem::Dependency
+  name: hoe
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.5'
+description: Optimized thrift bindings for ruby
+email:
+- evan@phx.io
+executables:
+- stark
+extensions: []
+extra_rdoc_files:
+- History.txt
+- Manifest.txt
+- README.txt
+files:
+- .autotest
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- bin/stark
+- lib/stark.rb
+- lib/stark/ast.rb
+- lib/stark/client.rb
+- lib/stark/converters.rb
+- lib/stark/field.rb
+- lib/stark/log_transport.rb
+- lib/stark/parser.rb
+- lib/stark/processor.rb
+- lib/stark/raw_parser.rb
+- lib/stark/ruby.rb
+- lib/stark/struct.rb
+- lib/stark/thrift.kpeg
+- stark.gemspec
+- test/ThriftSpec.thrift
+- test/gen-rb/profile_constants.rb
+- test/gen-rb/profile_types.rb
+- test/gen-rb/user_storage.rb
+- test/leg.rb
+- test/legacy_profile/profile_constants.rb
+- test/legacy_profile/profile_types.rb
+- test/legacy_profile/user_storage.rb
+- test/profile.thrift
+- test/test_client.rb
+- test/test_parser.rb
+- test/test_server.rb
+- .gemtest
+homepage: http://github.com/evanphx/stark
+licenses: []
+post_install_message: 
+rdoc_options:
+- --main
+- README.txt
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: stark
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: Optimized thrift bindings for ruby
+test_files:
+- test/test_client.rb
+- test/test_parser.rb
+- test/test_server.rb