malachite 0.0.8 → 0.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 07a0d476e0764cb08d2117b7d538dd8e5a64ed11
-  data.tar.gz: 2ccccc678e2395196cbff0c83a7b47f017196f3b
+  metadata.gz: 74395f3bd70b33d34c59da34c3e8cfcf58a6a53f
+  data.tar.gz: 425ee905e2b18d16bc61e770ab468b0c151f06fc
 SHA512:
-  metadata.gz: f0a826099b4868083018805211858d24d463c5632fda704220bdc9b4c8f860e41cae6e94b6a8d669c6318d08f306b90fd5f50e3ce6a8a144ba222bc8a8422548
-  data.tar.gz: df07b50d3d0654e87a88db32635e3c43dfd2dceff93e2056e050bd9ebac8d8b68c92fe16885c8f1cce94aef2230850d6810a1ff95f1bd5403b886461add6b76e
+  metadata.gz: ee2075a956557036e812b06a6a8d573204bbace086615343a98f41c614b645b519fe9143558ad75e4626d6c56bfc871f6089b341136c7ee7c81c8d09ac11d76f
+  data.tar.gz: e396d11d21e26ecafa4df81f0ad19395c7b4eb457661a643e942fa2d0b8ac10b311e7e2a7485d24d28cf3163b59c3c30bce7a092704a623f12a00a4bcb245b19

data/README.md

@@ -9,20 +9,20 @@ Install [Go 1.5 or later](https://golang.org/doc/install) on relevant machines.
 Add this to your Gemfile:
 
 ```ruby
-gem 'malachite', github: 'zhubert/malachite'
+gem 'malachite'
 ```
 
 Make a subdirectory of "app" called "go".
 
 ### Write Some Go Functions
 
-Everything in "app/go" will get compiled into one namespace, so to get it to work with
+Everything in ```app/go```will get compiled into one namespace, so to get it to work with
 Malachite, you need to:
 
-* name the methods you want exported like: "HandleFoo"
-* the Handle methods can only take one argument (use structs for more complexity)
+* name the methods you want exported like: ```HandleFoo```
+* the Handle methods can only take one argument (use [structs](https://github.com/zhubert/malachite/wiki/Structs) for more complexity)
 
-For instance, if you wanted to upcase strings more quickly in your Rails app, you'd put the following in the file "app/go/upcase.go":
+For instance, if you wanted to upcase strings more quickly in your Rails app, you'd put the following in the file ```app/go/upcase.go```:
 
 ```go
 package main
@@ -42,77 +42,23 @@ func HandleUpcase(things []string) (upperCased []string) {
 Then use your function from Rails:
 
 ```ruby
-Malachite::Client.upcase(["foo","bar"])
+Malachite.upcase(["foo","bar"])
 => ["FOO", "BAR"]
 ```
 
-Or if you have more interesting data organize it with a struct:
+More examples can be found in [examples](https://github.com/zhubert/malachite/wiki/Examples).
 
-```go
-package main
-
-import "strings"
-
-type Person struct {
-	Name string `json:"name"`
-	Age  string `json:"age"`
-}
-
-func HandleStructured(people []Person) (upperCasedPeople []Person) {
-	for _, person := range people {
-		upCase := Person{strings.ToUpper(person.Name), person.Age}
-		upperCasedPeople = append(upperCasedPeople, upCase)
-	}
-	return
-}
-```
-
-```ruby
-peeps = [{name: 'Peter', age: '27'},{name: 'Tim', age: '30'}]
-Malachite::Client.structured(peeps)
-=> [{"name"=>"PETER", "age"=>"27"}, {"name"=>"TIM", "age"=>"30"}]
-```
-
-Or even something totally arbitrary:
-
-```go
-package main
+### Testing
 
-import "strings"
-
-type Person struct {
-	Name string `json:"name"`
-}
+I'd encourage writing tests for your Go code in the usual fashion. ```app/go/upcase_test.go``` would be the right place for it in the example above.
 
-type Foo struct {
-	Friends []Person `json:"friends"`
-	Enemies []Person `json:"enemies"`
-}
-
-func HandleFrenemies(foo Foo) (frenemies []Person) {
-	for _, friend := range foo.Friends {
-		for _, enemy := range foo.Enemies {
-			if friend.Name == enemy.Name {
-				frenemies = append(frenemies, friend)
-			}
-		}
-	}
-	return
-}
-```
-
-```ruby
-friends = [{name: 'Peter'},{name: 'Tim'}]
-enemies = [{name: 'Peter'},{name: 'Zeb'}]
-Malachite::Client.frenemies({friends: friends, enemies: enemies})
-=> [{"name"=>"Peter"}]
-```
+Slightly more detail found in [Testing](https://github.com/zhubert/malachite/wiki/Testing)
 
 ### How Does it Work?
 
-Some code trickery, quite honestly.
+One part code generation, another part pure evil.
 
-* The first time the function is called, Malachite will build a shared library from all the Go code in your "app/go" folder
+* The first time the function is called, Malachite will build a shared library from all the Go code in your ```app/go``` folder
 * It then uses Ruby's Fiddle to call the shared library
 * Arguments are passed back and forth via JSON
 
@@ -121,9 +67,3 @@ Because of the JSON step, you'll only see real performance gains on computationa
 ### Ruby 2.2.4+
 
 It's strongly recommended to use the [newest release of Ruby](https://www.ruby-lang.org/en/news/2015/12/16/unsafe-tainted-string-usage-in-fiddle-and-dl-cve-2015-7551/) as there was a security issue with older versions of Fiddle.
-
-### TODO
-
-* Confirm Go's existence, raise exception on build
-* Error handling
-* Benchmark performance...roughly

data/lib/malachite/version.rb

@@ -1,3 +1,3 @@
 module Malachite
-  VERSION = '0.0.8'
+  VERSION = '0.0.9'
 end

data/lib/malachite.rb

@@ -11,6 +11,10 @@ require 'malachite/file_compiler'
 require 'malachite/compiler'
 
 module Malachite
+  def self.method_missing(name, args)
+    Malachite::Client.new(name, args).call
+  end
+
   def self.load_json(string)
     JSON.parse(string)
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: malachite
 version: !ruby/object:Gem::Version
-  version: 0.0.8
+  version: 0.0.9
 platform: ruby
 authors:
 - Zack Hubert
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-12-18 00:00:00.000000000 Z
+date: 2015-12-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json