zkruby 3.4.3

data/History.txt

@@ -0,0 +1,18 @@
+=== 3.4.3 /
+
+* Tidy up 
+
+  * simplify require statements (zkruby or em_zkruby)
+
+  * no need to separately require util recipes for recursive mkpath/rmpath
+
+  * specs can be run independently
+
+  * fix dependencies so rake newb works
+
+  * Use standard major.minor.build versioning. Major/Minor will track ZooKeeper itself, build is zkruby's
+
+=== 3.4.2.0 / 2012-02/05
+
+* First gem release. Tested against Zookeeper 3.4.2, and 3.3.3
+

data/Manifest.txt

@@ -0,0 +1,39 @@
+History.txt
+Manifest.txt
+README.rdoc
+Rakefile
+jute/jute.citrus
+jute/lib/hoe/jute.rb
+jute/lib/jute.rb
+lib/zkruby/bindata.rb
+lib/zkruby/enum.rb
+lib/zkruby/eventmachine.rb
+lib/zkruby/multi.rb
+lib/zkruby/protocol.rb
+lib/zkruby/rubyio.rb
+lib/zkruby/session.rb
+lib/zkruby/client.rb
+lib/zkruby/util.rb
+lib/zkruby/zkruby.rb
+lib/zkruby.rb
+lib/em_zkruby.rb
+spec/bindata_spec.rb
+spec/enum_spec.rb
+spec/eventmachine_spec.rb
+spec/multi_spec.rb
+spec/protocol_spec.rb
+spec/recipe_helper.rb
+spec/rubyio_spec.rb
+spec/sequences_spec.rb
+spec/shared/auth.rb
+spec/shared/basic.rb
+spec/shared/binding.rb
+spec/shared/chroot.rb
+spec/shared/multi.rb
+spec/shared/util.rb
+spec/shared/watch.rb
+spec/spec_helper.rb
+spec/server_helper.rb
+src/jute/zookeeper.jute
+lib/jute/zookeeper.rb
+yard_ext/enum_handler.rb

data/README.rdoc

@@ -0,0 +1,119 @@
+= zkruby
+
+* https://github.com/lwoggardner/zkruby
+
+== DESCRIPTION:
+
+Pure ruby client for ZooKeeper (http://zookeeper.apache.org)
+
+== FEATURES
+
+Supports full ZooKeeper API, synchronous or asynchronous style, watches etc.. with implementations over EventMachine or plain old Ruby IO/Threads
+
+Advantages:
+* Rubyist API - with block is asynchronous, without block is synchronous
+* Avoids conflicts between various Ruby threading models and the C/Java apis
+* Same code for JRuby or MRI
+* Connection bindings for pure ruby IO and eventmachine, or roll your own
+
+Disadvantages:
+* Duplicated code from Java/C libraries, particularly around herd effect protection
+* Maintain in parallel with breaking changes in protocol which are possibly more likely 
+  than breaking changes in the client API
+* Probably not as optimised in terms of performance (but your client code is ruby anyway) 
+* Not production tested (yet- do you want to be the first?)  
+
+== SYNOPSIS:
+
+0. Configure Slf4R Logging (https://rubygems.org/gems/slf4r)
+1. Get a connection {ZooKeeper.connect}
+2. Make requests on the returned {ZooKeeper::Client}
+
+  require 'slf4r/ruby_logging' 
+  require 'zkruby'
+
+  # Using ruby threads and sockets (default)
+  zk = ZooKeeper.connect("localhost:2181")
+  # Synchronous
+  stat = zk.exists("/aPath")
+
+  # Asynchronous
+  zk.exists("/aPath) { |stat| puts stat.inspect }
+
+  # Watches
+  watch = lambda { |state,path,event| puts "Watch fired #{state} #{path} #{event}" }
+
+  stat,data = zk.get("/aPath",watch)
+
+  # OR with EventMachine
+  require 'em_zkruby'
+  EventMachine.run do
+     # Magic of Fibers (via Strands) lets us code normally and execute asynchronously
+     Strand.new() do
+        begin
+            zk = ZooKeeper.connect("localhost:2181")
+            #Sync
+            path = zk.create("/aPath/mynode",ZK::ACL_ANYONE_UNSAFE,:ephemeral,:sequential) 
+
+            #Async
+            zk.get(path) do |stat,data|
+               puts "#{stat.inspect} #{data}" 
+            end
+            
+        rescue ZooKeeper::Error => zkex
+            puts zkex.message
+        end
+     end
+  end
+
+== REQUIREMENTS:
+
+* A ZooKeeper cluster to connect to
+* Ruby 1.9 (but a backport should be straightforward)
+
+== INSTALL:
+
+  $ (sudo) gem install zkruby
+
+== DEVELOPERS:
+
+Checkout the zookeeper source from http://zookeeper.apache.org
+
+Checkout the zkruby source into the contrib directory  
+
+Install hoe
+
+  $ (sudo) gem install hoe 
+
+Install other dependencies
+
+  $ rake check_extra_deps
+
+Generate docs and run the tests/specs
+
+  $ rake newb
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2011 
+
+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/Rakefile

@@ -0,0 +1,39 @@
+# -*- ruby -*-
+# hoe  2.12.5 goes looking for the plugins so we have to do it this way..
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/jute/lib'
+
+require 'rubygems'
+require 'hoe'
+
+begin
+    require './yard_ext/enum_handler'
+rescue LoadError => err
+     warn "%p while trying to load yard extensions: %s" % [ err.class, err.message ]
+end
+    
+
+
+# Hoe.plugin :compiler
+#Hoe.plugin :gem_prelude_sucks
+Hoe.plugin :git
+# Hoe.plugin :inline
+# Hoe.plugin :racc
+# Hoe.plugin :rubyforge
+Hoe.plugin :yard
+Hoe.plugin :jute
+
+Hoe.spec 'zkruby' do
+  self.readme_file="README.rdoc"
+  developer('Grant Gardner', 'grant@lastweekend.com.au')
+  dependency 'slf4r' , '~> 0.4.2' 
+  dependency 'eventmachine', '~> 0.12.10', :development 
+  dependency 'strand', '~> 0.1.0', :development 
+  dependency 'logging', '>= 1.4.1', :development
+  dependency 'rspec', '>=2.7.0', :development
+  dependency 'hoe-yard', '>=0.1.2', :development
+
+  self.jute_modules = {
+      "org.apache.zookeeper.data" => "ZooKeeper::Data",
+      "org.apache.zookeeper.proto" => "ZooKeeper::Proto"}
+end
+# vim: syntax=ruby

data/jute/jute.citrus

@@ -0,0 +1,105 @@
+grammar Jute
+ 
+    rule jute
+        (space* jmodule*) {
+
+                captures[:jmodule].inject(Hash.new()) do |h,m|
+                   h[m.name.value] = m.classes
+                   h
+                end
+        }   
+    end
+
+    rule jmodule
+       ('module' (space)1* name:identifier space* '{' space* jclass* '}' space*)  {
+           
+            def value
+                [ name.value, classes() ]
+            end
+
+            def classes
+               captures[:jclass].inject(Hash.new()) do |h,c|
+                 h[c.name.value] = c.jfields
+                 h
+               end
+            end
+
+       }
+    end
+
+    rule jclass
+       ('class' (space)1* name:class_identifier space* '{' space* jfield* '}' space*) {
+
+            def jfields
+               # field order is important!
+               captures[:jfield].collect() do |f| 
+                    f.value 
+               end
+            end
+       }
+    end
+
+    rule jfield
+        (ftype name:identifier space* ';' space*)  {
+            [ name.value, ftype.value ] 
+        }
+    end
+    
+    rule ftype
+      (parameterized_type | non_parameterized_type)
+    end
+
+    rule parameterized_type
+        vector 
+    end
+
+    rule non_parameterized_type
+        (basic_type (space)1*)
+        {
+            basic_type.value 
+        }
+    end
+
+    rule basic_type
+        (primitive_type | nested_record) 
+    end
+
+    rule primitive_type
+       ('int' | 'long' | 'boolean' | 'byte' | 'float' | 'double' | 'ustring' | 'buffer') {
+            to_sym
+       }
+    end
+
+    rule vector
+        ('vector' space* '<' space* vtype:(basic_type | parameterized_type) space* '>' space*) {
+            [ :vector, vtype.value ] 
+        }
+    end
+    
+    rule nested_record
+        identifier  {
+            components = split(".") 
+            module_name = components[0..-2].join(".") if components.length > 1
+            class_name = components.last
+            [ :record, module_name, class_name ]
+        }
+    end
+
+    rule space
+       [ \t\r\n] | line_comment | block_comment
+    end
+
+    rule line_comment
+         '//' (!eol .)* (eol | eof) space* 
+    end
+
+    rule block_comment
+        '/*' (!'*/' .)* '*/' space*
+    end
+   
+    rule class_identifier [a-zA-Z0-9_]1* end
+    rule identifier [a-zA-Z0-9_.]1* end
+    rule eof !. end
+    rule eol [\r\n] end
+    
+end

data/jute/lib/hoe/jute.rb

@@ -0,0 +1,56 @@
+# coding: utf-8
+
+module Hoe::Jute
+   attr_accessor :jute
+   attr_accessor :jute_tasks
+   attr_accessor :jute_modules
+
+   #attr_accessor :jute_compiler
+   def initialize_jute
+        self.jute_tasks = [:test,:spec,:package]
+        dependency 'citrus', '~> 2.4.0', :development
+        #dependency 'jute' # if jute is ever a separate gem
+        dependency 'bindata', '~> 1.4.1'
+   end
+
+   def define_jute_tasks
+
+      found = try_load_jute()
+
+      if found
+         jute_compiler = ::Jute::Compiler.new()
+         jute_files   = self.spec.files.find_all { |f| f =~ /\.jute$/ }
+
+         record_files = jute_files.map { |f| f.pathmap("%{src,lib}X.rb") }
+         self.clean_globs += record_files
+
+
+          rule ".rb" => ["%{lib,src}X.jute"] do |t|
+              File.open(t.source) do |input|
+                File.open(t.name,"w") do |output|
+                    puts "compiling #{input.inspect} to #{output.inspect}"
+                    jute_compiler.compile(input,output,jute_modules)
+                end
+              end
+          end
+
+          desc "generate jute records" unless jute_files.empty?
+          task :jute
+
+          task :jute => record_files
+
+          jute_tasks.each do |t|
+            task t => [:jute]
+          end
+       end
+   end
+
+   def try_load_jute()
+        require 'jute'
+   rescue LoadError => err
+        warn "%p while trying to load jute: %s" % [ err.class, err.message ]
+        false
+   end
+end
+
+

data/jute/lib/jute.rb

@@ -0,0 +1,120 @@
+# coding: utf-8
+require 'citrus'
+
+class String
+    def to_snake_case!
+        self.gsub!(/(.)([A-Z])/,'\1_\2')
+        self.downcase!
+    end
+
+    def to_snake_case
+        self.clone.to_underscore!
+    end
+end
+
+Citrus.load(File.dirname(__FILE__) + "/../jute.citrus")
+
+JUTE_TO_BINDATA = { :int => "int32be",
+    :long => "int64be",
+    :ustring => "zk_string",
+    :boolean => "zk_boolean",
+    :buffer => "zk_buffer",
+    :float => "float_be",
+    :double => "double_be" }
+
+module Jute
+class Compiler
+
+    attr_reader :invalid_names
+
+    def initialize()
+        @invalid_names = { 
+            "max" => "maximum",
+            "id" => "identity",
+            "Id" => "Identity",
+            "type" => "_type"
+        }
+        @selected_modules = {}
+    end
+
+    def compile(input,out,selected_modules={})
+
+        contents = input.read
+        modules = Jute.parse(contents).value
+
+        if (selected_modules.size > 0) 
+            modules = modules.select() do |k,v|
+                selected_modules.has_key?(k)
+            end
+        end
+
+            modules.each_pair do | mod_name, mod_info |
+
+                out << " module #{selected_modules[mod_name]}\n"
+
+                mod_info.each_pair do | record_name, record_info |
+                    record_name = classify(record_name)
+                    out << "  class #{record_name} < BinData::Record\n"
+
+                    record_info.each do | field_info |
+                        field_name, field_type = field_info
+                        field_name = invalid_names[field_name] || field_name 
+                        field_name.to_snake_case!
+                        case field_type
+                        when Symbol
+                            out << "    #{JUTE_TO_BINDATA[field_type]} :#{field_name}\n"
+                        when Array
+                            complex_type, *type_args = field_type
+                            send(complex_type, out, field_name, *type_args)
+                        else
+                            out << field_info.inspect << "\n"
+                        end
+                    end
+
+                    out << "  end\n"
+                end
+
+                out << " end\n"
+            end
+    end 
+
+    def vector(out, name,contained_type)
+        case contained_type
+        when  Symbol
+            out << "    hide :#{name}__length\n"
+            out << "    int32be :#{name}__length, :value => lambda { #{name}.length }\n"
+            out << "    array :#{name}, :type => :#{JUTE_TO_BINDATA[contained_type]}, :initial_length => :#{name}__length\n"
+        when  Array
+            complex_type, *type_args = contained_type
+            if (complex_type == :record)
+                out << "    hide :#{name}__length\n"
+                out << "    int32be :#{name}__length, :value => lambda { #{name}.length }\n"
+                out << "    array :#{name}, :type => :#{type_args[1].downcase}, :initial_length => :#{name}__length\n"
+            else
+                #TODO raise typerror
+            end
+        end
+
+    end
+
+    # TODO handle modules, for now the record_names must be unique
+    def record(out, field_name, module_name, record_name)
+        record_name = invalid_names[record_name] || record_name
+        out << "    #{record_name.downcase()} :#{field_name}\n"
+    end
+
+    # turn a record name into a legitimate ruby class name
+    def classify(record_name)
+        record_name = invalid_names[record_name] || record_name
+        return record_name.gsub(/(^|_)(.)/) { $2.upcase }
+    end
+end #class Compiler
+end #module Jute
+if __FILE__ == $0
+   compiler = JuteCompiler.new()
+   modules = { 
+       "org.apache.zookeeper.data" => "ZooKeeper::Data",
+       "org.apache.zookeeper.proto" => "ZooKeeper::Proto" }
+
+   compiler.compile(STDIN,STDOUT,modules) 
+end