zweikopf 0.0.6 → 0.4.0

data/README.md

@@ -17,8 +17,15 @@ Or install it yourself as:
 
     $ gem install zweikopf
 
+For Clojure-driven projects, add this line to your `project.clj`:
+
+```clojure
+[zweikopf "0.4.0"]
+```
 ## Usage
 
+### From Ruby code: Clojure->Ruby transformations
+
 Transfroming from Clojure entities to Ruby ones is as easy as:
 
 ```ruby
@@ -35,6 +42,8 @@ Zweikopf::Transformer.from_clj(clojure_var)
 # => {:a => 1, :b => {:c => [{:d => 2}, {:e => 3}, { :f => 4}]}}
 ```
 
+### From Ruby code: Ruby->Clojure transformations
+
 And backwards:
 
 ```ruby
@@ -51,6 +60,8 @@ Zweikopf::Transformer.from_ruby(ruby_var)
 # => {:a 1 :b {:c [{:d 2} {:e 3} {:f 4}]}}
 ```
 
+### Custom conversion
+
 When performing Ruby to Clojure transformation, you may leave out some space for customization:
 
 ```ruby
@@ -70,8 +81,74 @@ Zweikopf::Transformer.from_ruby({:a => 1, :b => CustomTransformedEntry.new }) do
 # => {:a 1 :b {:c 3 :d 4}}
 ```
 
+### From Clojure code:
+
+With Clojure version everything is extremely simple:
+
+```clojure
+(:require 'zweikopf.core)
+
+;; You _must_ call it, otherwise Ruby Runtime won't get initialized.
+(init-ruby-context)
+
+;; To convert Clojure DS to Ruby, run:
+(rubyize {:a 1 :b 2})
+
+;; To convert Ruby DS to Clojure, run
+(clojurize ruby-obj)
+
+;; If you want to execute arbitrary Ruby code, use ruby-eval:
+(ruby-eval "puts 'Hello World'") ;; Or any other portion of Ruby code you'd like to execute
+
+;; In order to require a file:
+(ruby-require "filename")
+
+;; In order to load:
+(ruby-load "filename")
+
+;; Call a method on a Ruby object:
+;; This will call `#to_hash` method on `ruby-obj`
+(call-ruby ruby-obj :to_hash)
+
+;; To set gem-path:
+(set-gem-path "my-gem-path")
+
+;; To set gem-home:
+(set-gem-path "my-gem-home")
+
+;; To add custom convertor from Ruby to Clojure, extend protocol Clojurize
+;; For example, convertion of RubyTime class to java Date
+(extend-protocol Clojurize
+  org.jruby.RubyTime
+  (clojurize [this]
+    (.toJava this java.util.Date)))
+
+;; To add custom convertor from Clojure to Ruby, extend protocol Rubyize
+;; For example, convertion of Clojure Keyword class to Ruby Symbol
+(extend-protocol Rubyize
+  clojure.lang.Keyword
+  (rubyize [this]
+    (.fastNewSymbol ruby-runtime (name this))))
+```
+
+# Pitfalls
+
+When using Rails and DateTime conversion, you should call `DateTime#utc` before you can call `#to_time`.
+
+It's very easy to package all your gems in a Jar, if you decide to do so, you need to either use
+the files that were extracted by the runtime (which is by itself quite tricky, and you may run into
+some issues with Bundler, if you use it), alternative is to materialize (extract) your gems from
+jar manually. We're not yet ready to open our sorce for jar extraction, but you can write up your
+own quite quickly, using `FileReader`, `JarFile` and `JarInputStream` files.
+
+Other than that, JRuby/Clojure integration is very smooth and painless.
+
 # Performance
 
+We highly recommend using target language convertor. If you pass rather small data structures to Ruby scripts,
+and return large portions back, use Clojure version. If you pass smaller amounts of data to Clojure code,
+and it returns larger cunks, use Ruby version of transformer.
+
 ## Conversion from Ruby hash to Clojure PersistentHash Map
 
 Most of time 52% according to the rough estimate is spent while converting from ruby Symbol to clojure Keyword.
@@ -86,6 +163,10 @@ Most of time 52% according to the rough estimate is spent while converting from
 
 # Copyright
 
-Copyright (C) 2011-2012 Alex Petrov, Maximilian Karasz, Daniel Steiner, Roman Flammer.
+Copyright (C) 2012-2013 Alex Petrov and [contributors](https://github.com/ifesdjeen/zweikopf/graphs/contributors).
 
 Distributed under the Eclipse Public License, the same as Clojure.
+
+
+[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/ifesdjeen/zweikopf/trend.png)](https://bitdeli.com/free "Bitdeli Badge")
+

data/lib/zweikopf/version.rb

@@ -1,3 +1,3 @@
 module Zweikopf
-  VERSION = "0.0.6"
+  VERSION = "0.4.0"
 end

data/project.clj

@@ -1,5 +1,5 @@
-(defproject zweikopf "0.1.0-SNAPSHOT"
+(defproject zweikopf "1.0.0-SNAPSHOT"
   :description "jruby clojure interop"
   :dependencies [[org.clojure/clojure "1.4.0"]
-                 [org.jruby/jruby-complete "1.6.7.2"]]
+                 [org.jruby/jruby-complete "1.7.1"]]
   :profiles {:dev {:dependencies []}})

data/spec/zweikopf/performance_spec.rb

@@ -14,8 +14,9 @@ describe :performance do
 
   it "this spec simply shows performance, very roughly, please do your testing depending on your needs" do
     time_before = Time.now.to_f
+    ruby_obj = {:a => 1, :b => 2}
     100000.times do |i|
-      Zweikopf::Transformer.from_ruby({:a => i, :b => i})
+      Zweikopf::Transformer.from_ruby(ruby_obj)
     end
     puts "Ruby to Clojure, time elapsed: #{Time.now.to_f - time_before} seconds"
 

data/src/zweikopf/core.clj

@@ -1,33 +1,45 @@
 (ns zweikopf.core
-  (:require [clojure.reflect :as r])
-  (:import [org.jruby RubyObject RubyHash RubyBasicObject
-            RubySymbol RubyHash$RubyHashEntry RubyArray]
-           [org.jruby.javasupport JavaUtil]))
-
-(defprotocol Clojurize
-  (clojurize [this]))
-
-(extend-protocol Clojurize
-  java.lang.Object
-  (clojurize [this] this)
-  RubyObject
-  (clojurize [this] (JavaUtil/convertRubyToJava this))
-  RubySymbol
-  (clojurize [^RubySymbol this]
-             (clojure.lang.Keyword/intern (.toString this)))
-  RubyHash
-  (clojurize [^RubyHash this]
-             (loop [[^RubyHash$RubyHashEntry entry & entries] (seq (.directEntrySet this))
-                    acc (transient {})]
-               (if entry
-                 (recur entries
-                        (assoc! acc (clojurize (.getKey entry))
-                                (clojurize (.getValue entry))))
-                 (persistent! acc))))
-  RubyArray
-  (clojurize [^RubyArray this]
-             (loop [[entry & entries] (seq this)
-                    acc (transient [])]
-               (if entry
-                 (recur entries (conj! acc (clojurize entry)))
-                 (persistent! acc)))))
+  (:require [zweikopf.multi :as multi])
+  (:import [org.jruby.embed ScriptingContainer LocalContextScope]
+           [org.jruby Ruby]))
+
+(declare ^ScriptingContainer ruby)
+(declare ^Ruby ruby-runtime)
+
+(defn clojurize
+  [this]
+  (multi/clojurize this ruby))
+
+(defn rubyize
+  [this]
+  (multi/rubyize this ruby))
+
+(defn ruby-eval
+  [script]
+  (multi/ruby-eval ruby script))
+
+(defn ruby-require
+  [lib]
+  (ruby-eval (format "require '%s'" lib)))
+
+(defn ruby-load
+  [lib]
+  (ruby-eval (format "load '%s'" lib)))
+
+(defn call-ruby
+  [& args]
+  (apply multi/call-ruby ruby args))
+
+(defn set-gem-path
+  "Sets GEM_PATH Environment variable"
+  [gem-path]
+  (ruby-eval (str "ENV['GEM_PATH']='" gem-path "'")))
+
+(defn set-gem-home
+  [gem-home]
+  (ruby-eval (str "ENV['GEM_HOME']='" gem-home "'")))
+
+(defn init-ruby-context
+  []
+  (defonce ruby (ScriptingContainer. LocalContextScope/SINGLETON))
+  (defonce ruby-runtime (.getRuntime (.getProvider ruby))))

data/src/zweikopf/multi.clj

@@ -0,0 +1,145 @@
+(ns zweikopf.multi
+  (:require [clojure.string :as str])
+  (:import (org.jruby.embed ScriptingContainer
+                            LocalContextScope)
+           (org.jruby Ruby
+                      RubyArray
+                      RubyBasicObject
+                      RubyHash
+                      RubyHash$RubyHashEntry
+                      RubyObject
+                      RubyRational
+                      RubyString
+                      RubySymbol)))
+
+(defprotocol Clojurize
+  (clojurize [this ^ScriptingContainer ruby]))
+
+(defprotocol Rubyize
+  (rubyize [this ^ScriptingContainer ruby]))
+
+(defn- ^Ruby runtime
+  [^ScriptingContainer container]
+  (-> container .getProvider .getRuntime))
+
+(defn ruby-eval
+  [^ScriptingContainer ruby script]
+  (.runScriptlet ruby script))
+
+(defn call-ruby
+  [^ScriptingContainer container klass method & args]
+  (let [method-name (name method)
+        klass (if (string? klass)
+                (ruby-eval container (str/replace klass "/" "::"))
+                klass)]
+    (if (empty? args)
+      (.callMethod container klass method-name Object)
+      (.callMethod container klass method-name (object-array args) Object))))
+
+(defn context
+  []
+  (ScriptingContainer. LocalContextScope/SINGLETHREAD))
+
+(defn terminate
+  [^ScriptingContainer ctx]
+  (.terminate ctx))
+
+(extend-protocol Clojurize
+  nil
+  (clojurize [this _]
+    nil)
+
+  RubySymbol
+  (clojurize [this _]
+    (clojure.lang.Keyword/intern (.toString this)))
+
+  RubyHash
+  (clojurize [this ruby]
+    (persistent!
+      (reduce (fn [acc ^RubyHash$RubyHashEntry entry]
+                (assoc! acc
+                        (clojurize (.getKey entry) ruby)
+                        (clojurize (.getValue entry) ruby)))
+              (transient {})
+              (.directEntrySet this))))
+
+  RubyArray
+  (clojurize [this ruby]
+    (mapv #(clojurize % ruby) this))
+
+  RubyString
+  (clojurize [this _]
+    (.decodeString this))
+
+  org.jruby.RubyNil
+  (clojurize  [_ _]
+    nil)
+
+  org.jruby.RubyRational
+  (clojurize [this ruby]
+    (let [context (.getCurrentContext (runtime ruby))
+          numerator (clojurize (.numerator this context) ruby)
+          denominator (clojurize (.denominator this context) ruby)]
+      (/ numerator denominator)))
+
+  org.jruby.RubyFixnum
+  (clojurize  [this _]
+    (.getLongValue this))
+
+  org.jruby.RubyFloat
+  (clojurize  [this _]
+    (.getDoubleValue this))
+
+  org.jruby.RubyBoolean
+  (clojurize  [this _]
+    (.isTrue this))
+
+  org.jruby.RubyTime
+  (clojurize [this _]
+    (.toJava this java.util.Date))
+
+  org.jruby.RubyObject
+  (clojurize [this ruby]
+    (condp #(call-ruby ruby %2 :respond_to? %1) this
+      "to_hash"   (clojurize (call-ruby ruby this :to_hash) ruby)
+      "strftime"  (-> (call-ruby ruby this :strftime "%s")
+                      Long/parseLong
+                      (* 1000)
+                      java.util.Date.)))
+
+  java.lang.Object
+  (clojurize [this _]
+    this))
+
+(defn- apply-to-keys-and-values [m f]
+  (into {} (for [[k v] m]
+             [(f k) (f v)])))
+
+(extend-protocol Rubyize
+  clojure.lang.IPersistentMap
+  (rubyize [this ruby]
+    (doto (RubyHash. (runtime ruby))
+      (.putAll (apply-to-keys-and-values this #(rubyize % ruby)))))
+
+  clojure.lang.Ratio
+  (rubyize [this ruby]
+    (RubyRational/newRational (runtime ruby)
+                              (.numerator this)
+                              (.denominator this)))
+
+  clojure.lang.Seqable
+  (rubyize [this ruby]
+    (doto (RubyArray/newArray (runtime ruby))
+      (.addAll (for [item this] (rubyize item ruby)))))
+
+  clojure.lang.Keyword
+  (rubyize [this ruby]
+    (.fastNewSymbol (runtime ruby) (name this)))
+
+  java.lang.Object
+  (rubyize [this _]
+    this)
+
+  nil
+  (rubyize [_ _]
+    nil))

data/test/zweikopf/core_test.clj

@@ -3,21 +3,88 @@
   (:use clojure.test
         zweikopf.core))
 
-(defn run-ruby-script [script]
-  (.runScriptlet (ScriptingContainer.) script))
+(use-fixtures :once (fn [f]
+                      (init-ruby-context)
+                      (f)))
 
-(deftest hash-test
+
+(deftest clojurize-test
+  (ruby-eval "require 'date'")
+  (testing "Numbers"
+    (testing "Integer"
+      (is (= 123 (clojurize (ruby-eval "123")))))
+    (testing "Floating point"
+      (is (= 123.45 (clojurize (ruby-eval "123.45")))))
+    (testing "Rational"
+      (is (= 1/3 (clojurize (ruby-eval "Rational(1,3)")))))
+    (testing "Big Decimals"
+      (is (= 12.34M (clojurize (ruby-eval "require 'bigdecimal'; BigDecimal.new(12.34,4)"))))))
   (testing "Empty hash"
-    (is (= {} (clojurize (run-ruby-script "{}")))))
+    (is (= {} (clojurize (ruby-eval "{}")))))
   (testing "Non-empty hash"
-    (is (= {:a 1 :b 2} (clojurize (run-ruby-script "{:a => 1, :b =>2 }")))))
+    (is (= {:a 1 :b 2} (clojurize (ruby-eval "{:a => 1, :b =>2 }")))))
+  (testing "Deep hash"
+    (is (= {:a 1 :b {:c 3 :d 4}} (clojurize (ruby-eval "{:a => 1, :b => {:c => 3, :d =>4}}")))))
+  (testing "Empty array"
+    (is (= [] (clojurize (ruby-eval "[]")))))
+  (testing "Non-empty array"
+    (is (= [1 :a "b"]) (clojurize (ruby-eval "[1, :a, 'b']"))))
+  (testing "Deep array"
+    (is (= [:a [:c :d] :e :f]) (clojurize (ruby-eval "[:a, [:c, :d], :e, :f]"))))
+  (testing "Complex DS"
+    (is (= [:a [:c {:d :e}] :f :g] (clojurize (ruby-eval "[:a, [:c, {:d => :e}], :f, :g]")))))
+  (testing "Times"
+    (testing "DateTime"
+      (let [date (clojurize (ruby-eval "DateTime.new(2013,2,19,12,34,56)"))] ;; => Tue, 19 Feb 2013 12:34:56 +0000
+        (is (= java.util.Date (class date)))
+        (is (= #inst "2013-02-19T12:34:56" date))))))
+
+(deftest rubyize-test
+  (testing "Numbers"
+    (testing "Integer"
+      (is (= (ruby-eval "123")
+             (rubyize 123))))
+    (testing "Floating point"
+      (is (= (ruby-eval "123.45")
+             (rubyize 123.45))))
+    (testing "Rational"
+      (is (= (ruby-eval "Rational(1,3)")
+             (rubyize 1/3))))
+    (testing "Big Decimals"
+      (is (= (ruby-eval "require 'bigdecimal'; BigDecimal.new(12.34,4)")
+             (rubyize 12.34M)))))
+  (testing "Emtpy hash"
+    (is (.equals (ruby-eval "{}") (rubyize {}))))
+  (testing "Non-emtpy hash"
+    (is (.equals (ruby-eval "{:a => 1, :b => 2}") (rubyize {:a 1 :b 2}))))
   (testing "Deep hash"
-    (is (= {:a 1 :b {:c 3 :d 4}} (clojurize (run-ruby-script "{:a => 1, :b => {:c => 3, :d =>4}}"))))))
+    (is (.equals (ruby-eval "{:a => 1, :b => {:c => 3, :d =>4}}") (rubyize {:a 1 :b {:c 3 :d 4}}))))
 
-(deftest array-test
   (testing "Empty array"
-    (is (= [] (clojurize (run-ruby-script "[]")))))
+    (is (= (ruby-eval "[]") (rubyize []))))
+
+  (testing "Empty list"
+    (is (= (ruby-eval "[]") (rubyize '()))))
+
   (testing "Non-empty array"
-    (is (= [1 :a "b"]) (run-ruby-script "[1, :a, 'b']")))
+    (is (= (ruby-eval "[1, :a, 'b']") (rubyize [1 :a "b"])) ))
+
+  (testing "Lazy seq"
+    (is (= (ruby-eval "[:a, :b, :c]") (rubyize (lazy-seq [:a :b :c])))))
+
   (testing "Deep array"
-    (is (= [:a [:c :d] :e :f]) (run-ruby-script "[:a, [:c, :d], :e, :f]"))))
+    (is (= (ruby-eval "[:a, [:c, :d], :e, :f]") (rubyize [:a [:c :d] :e :f])) ))
+
+  (testing "Complex DS"
+    (is (= (ruby-eval "[:a, [:c, {:d => :e}], :f, :g]") (rubyize [:a [:c {:d :e}] :f :g])))))
+
+(deftest performance
+  (testing "this spec simply shows performance, very roughly, please do your testing depending on your needs"
+    (time
+     (let [ruby-obj (ruby-eval "{:a => 1, :b => 2 }")]
+       (dotimes [i 100000]
+         (clojurize ruby-obj))))
+    (time
+     (let [clj-obj {:a 1 :b 2}]
+       (dotimes [i 100000]
+         (rubyize clj-obj))))))

metadata

@@ -2,7 +2,7 @@
 name: zweikopf
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.0.6
+  version: 0.4.0
 platform: ruby
 authors: 
   - Oleksandr Petrov
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-12-07 00:00:00 Z
+date: 2014-01-27 00:00:00 Z
 dependencies: 
   - !ruby/object:Gem::Dependency 
     name: rake
@@ -72,6 +72,7 @@ files:
   - spec/zweikopf/transformer_clojure_to_ruby_spec.rb
   - spec/zweikopf/transformer_ruby_to_clojure_spec.rb
   - src/zweikopf/core.clj
+  - src/zweikopf/multi.clj
   - test/zweikopf/core_test.clj
   - zweikopf.gemspec
 homepage: ""