quartz 0.2.2 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a9b32688049786025781cf7243a2cab933d83d0d
-  data.tar.gz: ca72a56ea8e7098daf9a05560353e0982c3c67b4
+  metadata.gz: 39afea8c7e6257e1015e85a28419bfe839879c2b
+  data.tar.gz: dd1345ed700b6e1b343d382436ed14f3032352ef
 SHA512:
-  metadata.gz: 979ad4c2465c424464c0f40ac89f0671959ec27f6d91cbfe45099b409fa9d95ae45a325d5a3a230c69066d203a29f5d0281e85747f639539c1b74846dceec52d
-  data.tar.gz: 86fad9d659b2912ba1bab12afe798f7eb44477062737a770e69db3865ad5351428da0bbf1c00edb2f09b71dac4d5bf772a45747991c607ca9a0cad05af2b2e28
+  metadata.gz: bad1814c347eb1e6727b208bb30b09b288af48f18a5a3e2014cd5e20d1e9108fda38e1c86388c2177913db07b0e14ca7b82d0d4b0d1657645cac2b1570cb29a8
+  data.tar.gz: c8913655aea693c38519c7fe4165d31f9f85708f73ac648d4b2fa3a2f26365f1b1c2e068c0ec3ec9e34bb01a72d37c594bea3e091fbec3c695b9038de7931e3d

data/README.md

@@ -1,6 +1,6 @@
 # quartz
 
-[![Build Status](https://travis-ci.org/DavidHuie/quartz.svg?branch=master)](https://travis-ci.org/DavidHuie/quartz)
+[![Build Status](https://travis-ci.org/DavidHuie/quartz.svg?branch=master)](https://travis-ci.org/DavidHuie/quartz) [![Code Climate](https://codeclimate.com/github/DavidHuie/quartz.png)](https://codeclimate.com/github/DavidHuie/quartz)
 
 Quartz enables you to call Go code from within your
 Ruby code. This is accomplished by running a Go program
@@ -18,9 +18,9 @@ the `examples/` directory.
 Quartz shares Go code by exporting methods on a struct to Ruby.
 
 Quartz requires that all arguments to exported struct methods be JSON-serializable
-structs. Additionally, the arguments to an exported method should be of the form
-`(A, *B)`, where `A` and `B` are struct types. The method should also return an error.
-Here's an example of an exportable struct and method:
+types. Additionally, the arguments to an exported method should be of the form
+`(A, *B)`, where `A` and `B` are JSON-serializable types. The method should also
+return an error. Here's an example of an exportable struct and method:
 
 ```go
 type Adder struct{}

data/VERSION

@@ -1 +1 @@
-0.2.2
+0.2.3

data/go/quartz/quartz.go

@@ -1,7 +1,6 @@
 package quartz
 
 import (
-	"encoding/json"
 	"net"
 	"net/rpc"
 	"net/rpc/jsonrpc"
@@ -11,20 +10,26 @@ import (
 	"syscall"
 )
 
-var (
-	quartz   *Quartz
-	listener net.Listener
-)
-
+// This holds information about exported structs.
 type Quartz struct {
 	Registry map[string]*StructMetadata
 }
 
-type MethodMetadata struct {
-	Method         reflect.Method `json:"-"`
-	ArgumentToType map[string]string
+// Return's the struct registry. This method is exported via RPC
+// so that the Ruby client can have knowledge about which structs and
+// which methods are exported.
+func (q *Quartz) GetMetadata(_ interface{}, value *map[string]*StructMetadata) error {
+	*value = q.Registry
+	return nil
 }
 
+var (
+	quartz = &Quartz{
+		Registry: make(map[string]*StructMetadata),
+	}
+	socketPath = "/tmp/quartz.socket"
+)
+
 type StructMetadata struct {
 	NameToMethodMetadata map[string]*MethodMetadata
 	TargetStruct         interface{} `json:"-"`
@@ -37,106 +42,55 @@ func NewStructMetadata(targetStruct interface{}) *StructMetadata {
 	}
 }
 
-func RegisterName(name string, s interface{}) error {
-	// TODO: check that s is a pointer
+type MethodMetadata struct {
+	Method         reflect.Method `json:"-"`
+	ArgumentToType map[string]string
+}
 
+// Exports a struct via RPC and generates metadata for each of the struct's methods.
+func RegisterName(name string, s interface{}) error {
 	quartz.Registry[name] = NewStructMetadata(s)
-
 	t := reflect.TypeOf(s)
 	for i := 0; i < t.NumMethod(); i++ {
 		method := t.Method(i)
-
 		// TODO: only export methods with JSON serializable arguments
 		// and responses.
-
 		metadata := &MethodMetadata{
 			method,
 			StructFieldToType(method.Type.In(1)),
 		}
-
 		quartz.Registry[name].NameToMethodMetadata[method.Name] = metadata
 	}
-
-	return nil
+	return rpc.RegisterName(name, s)
 }
 
+// Given a struct type, creates a mapping of field name
+// to string representation of the field name's type.
 func StructFieldToType(t reflect.Type) map[string]string {
 	fieldToType := make(map[string]string)
-
 	for i := 0; i < t.NumField(); i++ {
 		fieldToType[t.Field(i).Name] = t.Field(i).Type.String()
 	}
-
 	return fieldToType
 }
 
-type CallArgs struct {
-	StructName string
-	Method     string
-	MethodArgs string
-}
-
-func (q *Quartz) Call(args *CallArgs, response *interface{}) error {
-
-	// TODO: validate args
-
-	metadata := quartz.Registry[args.StructName]
-	method := metadata.NameToMethodMetadata[args.Method].Method
-
-	structValue := reflect.ValueOf(metadata.TargetStruct)
-	methodArgsValue := reflect.ValueOf([]byte(args.MethodArgs))
-	unmarshallerValue := reflect.ValueOf(json.Unmarshal)
-	functionResponse := reflect.Indirect(reflect.ValueOf(response))
-
-	// Determine what arguments the function requires
-	argsType := method.Type.In(1)
-	responseType := method.Type.In(2).Elem()
-	responseValuePointer := reflect.New(responseType)
-
-	// Create a value that's a direct reference to the arg argument
-	argStructPointer := reflect.New(argsType)
-	argStruct := reflect.Indirect(argStructPointer)
-
-	// Unmarshall the argument json
-	// TODO: check for unmarshalling errors
-	unmarshallerValue.Call([]reflect.Value{methodArgsValue, argStructPointer})
-
-	// Call the method
-	err := method.Func.Call([]reflect.Value{structValue, argStruct, responseValuePointer})
-	if !err[0].IsNil() {
-		return err[0].Interface().(error)
-	}
-
-	// Set this method's response value
-	rpcResponse := reflect.Indirect(responseValuePointer)
-	functionResponse.Set(rpcResponse)
-
-	return nil
-}
-
-func (q *Quartz) GetMetadata(_ interface{}, value *map[string]*StructMetadata) error {
-	*value = q.Registry
-	return nil
-}
-
-func init() {
-	socket_path := os.Getenv("QUARTZ_SOCKET")
-	if socket_path == "" {
-		socket_path = "/tmp/quartz.socket"
-	}
-
-	var err error
-	listener, err = net.Listen("unix", socket_path)
+func Start() {
+	// Start the server and accept connections on a
+	// UNIX domain socket.
+	rpc.Register(quartz)
+	listener, err := net.Listen("unix", socketPath)
 	if err != nil {
 		panic(err)
 	}
+	for {
+		conn, err := listener.Accept()
+		if err != nil {
+			panic(err)
+		}
+		go jsonrpc.ServeConn(conn)
+	}
 
-	quartz = &Quartz{}
-	quartz.Registry = make(map[string]*StructMetadata)
-
-	rpc.Register(quartz)
-
-	// Cleanup the socket file when the server is killed
+	// Destroy the socket file when the server is killed.
 	sigc := make(chan os.Signal)
 	signal.Notify(sigc, syscall.SIGTERM)
 	go func() {
@@ -149,12 +103,9 @@ func init() {
 	}()
 }
 
-func Start() {
-	for {
-		conn, err := listener.Accept()
-		if err != nil {
-			panic(err)
-		}
-		go jsonrpc.ServeConn(conn)
+func init() {
+	// The Ruby gem sets this environment variable for us.
+	if os.Getenv("QUARTZ_SOCKET") != "" {
+		socketPath = os.Getenv("QUARTZ_SOCKET")
 	}
 }

data/lib/quartz/go_process.rb

@@ -57,6 +57,8 @@ class Quartz::GoProcess
     payload = {
       'method' => 'Quartz.GetMetadata',
       'params' => [],
+      # This parameter isn't needed because we use a different
+      # connection for each thread.
       'id' => 1
     }
 
@@ -72,15 +74,10 @@ class Quartz::GoProcess
 
   def call(struct_name, method, args)
     payload = {
-      'method' => 'Quartz.Call',
-      'params' => [{
-          'StructName' => struct_name,
-          'Method' => method,
-          'MethodArgs' => args.to_json
-        }],
+      'method' => "#{struct_name}.#{method}",
+      'params' => [args],
       'id' => 1
     }
-
     socket.send(payload.to_json, 0)
     read
   end

data/lib/quartz/go_struct.rb

@@ -27,7 +27,7 @@ class Quartz::GoStruct
         raise "Invalid argument: #{k}"
       end
 
-      # TODO: validate type
+      # TODO: validate types
     end
 
     response = @process.call(@struct_name, method_name, args)

data/quartz.gemspec

@@ -2,11 +2,11 @@
 # DO NOT EDIT THIS FILE DIRECTLY
 # Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
-# stub: quartz 0.2.2 ruby lib
+# stub: quartz 0.2.3 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "quartz"
-  s.version = "0.2.2"
+  s.version = "0.2.3"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib"]

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: quartz
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.2.3
 platform: ruby
 authors:
 - David Huie