couchbase-jruby-client 0.2.2-java → 1.0.4-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8ec71506555414ea67468af719e184392afa4704
-  data.tar.gz: 74653b08496b561fcf60bae9c03a836c47acff4c
+  metadata.gz: 97f6ffc94c3d26dea77d88c7f57145ac9b8b061b
+  data.tar.gz: 5f969c7a83b8c5a62e2cd003f05182ddb9977091
 SHA512:
-  metadata.gz: 5bbc04e04898e8505bc3ffd4ce5223c2ab2f13a0200c4c7eae0ddd3eb8ca61797f1f9e3b244f1aaff7c862c0e108e00469345c42e1420e137ffb5d2992c7ab9e
-  data.tar.gz: dfa98216f38e6ce0d8282ef7befe1bc85a2efe5332692df1f113e12d1d94a2e1332784f31e0fa5c9f9b28750ca895f1515461afff9abc062f1ad0b3150b1ec98
+  metadata.gz: 9a04e21b82c3af1c422378f161d0102a5996788a1aa556f59e01618228643208acafe712e53e456bea8ead32cd35d3734b383b90c3c3bf9f06b2dfb73d2ac4e5
+  data.tar.gz: 52babb42001362e77794530e70113985b0fc08229c96c3beb1fd3b3a8602df6d8d9b16092f3de09543046be8da1a2295531a243682ca032f189a8f416f03dd24

data/.rubocop.yml

@@ -0,0 +1,103 @@
+AllCops:
+  Includes:
+    - '**/Gemfile'
+    - '**/Rakefile'
+
+Style/EmptyLinesAroundClassBody:
+  Enabled: false
+
+Style/EmptyLinesAroundModuleBody:
+  Enabled: false
+
+Style/ModuleFunction:
+  Enabled: false
+
+Metrics/AbcSize:
+  Enabled: true
+  Max: 20
+
+# Avoid long parameter lists
+ParameterLists:
+  Max: 3
+  CountKeywordArgs: true
+
+MethodLength:
+  CountComments: false
+  Max: 15 # TODO: lower to 15
+
+ClassLength:
+  CountComments: false
+  Max: 132 # TODO: lower to 100
+
+CyclomaticComplexity:
+  Max: 6 # TODO: lower to 6
+
+# Avoid more than `Max` levels of nesting.
+BlockNesting:
+  Max: 3
+
+# Align with the style guide.
+CollectionMethods:
+  PreferredMethods:
+    collect:  'map'
+    inject:   'reduce'
+    find_all: 'select'
+
+AccessModifierIndentation:
+  Enabled: false
+
+# Limit line length
+LineLength:
+  Enabled: false
+
+# Disable documentation checking until a class needs to be documented once
+Documentation:
+  Enabled: false
+
+# Not all trivial readers/writers can be defined with attr_* methods
+TrivialAccessors:
+  Enabled: false
+
+# Enforce Ruby 1.8-compatible hash syntax
+# HashSyntax:
+#   EnforcedStyle: hash_rockets
+
+# No spaces inside hash literals
+# SpaceInsideHashLiteralBraces:
+#   EnforcedStyle: no_space
+
+Style/MultilineOperationIndentation:
+  Enabled: true
+  EnforcedStyle: indented
+
+# Allow dots at the end of lines
+DotPosition:
+  Enabled: false
+
+# Don't require magic comment at the top of every file
+Encoding:
+  Enabled: false
+
+# Enforce outdenting of access modifiers (i.e. public, private, protected)
+# AccessModifierIndentation:
+#   EnforcedStyle: outdent
+
+EmptyLinesAroundAccessModifier:
+  Enabled: true
+
+# Align ends correctly
+EndAlignment:
+  AlignWith: variable
+
+# Indentation of when/else
+# CaseIndentation:
+#   IndentWhenRelativeTo: end
+#   IndentOneStep: false
+
+# Use the old lambda literal syntax
+# Lambda:
+#   Enabled: false
+
+# Semicolon:
+#   Exclude:
+#     - 'spec/support/'

data/.ruby-version

@@ -1 +1 @@
-jruby-1.7.11
+jruby-1.7.21@cb-client

data/Rakefile

@@ -1,5 +1,16 @@
 require 'bundler/gem_tasks'
+require 'rake/testtask'
 
-Dir['tasks/*.rake'].sort.each { |f| load f }
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
 
-task :default => :test
+task default: :test
+
+task :pry do
+  require 'couchbase'
+  require 'pry'
+  Pry.start
+end

data/couchbase-jruby-client.gemspec

@@ -19,13 +19,14 @@ Gem::Specification.new do |s|
   s.test_files    = s.files.grep(%r{^(test|spec|features)/})
   s.require_paths = ['lib']
 
-  s.add_runtime_dependency 'multi_json',    '>= 1.0'
-  s.add_runtime_dependency 'thread_safe',   '>= 0.1.2'
+  s.add_runtime_dependency 'multi_json'
+  # s.add_runtime_dependency 'jbundler'
+  # s.requirements << "jar 'com.couchbase:java-client', '2.1.1'"
 
-  s.add_development_dependency 'bundler',   '>= 1.3'
+  s.add_development_dependency 'bundler'
   s.add_development_dependency 'rake'
-  s.add_development_dependency 'minitest',  '>= 5.1.0'
-  s.add_development_dependency 'jrjackson', '>= 0.2.3'
+  s.add_development_dependency 'minitest'
+  s.add_development_dependency 'jrjackson'
   s.add_development_dependency 'pry'
-  s.add_development_dependency 'mocha'
+  s.add_development_dependency 'rubocop'
 end

data/lib/couchbase/bucket.rb

@@ -16,357 +16,30 @@
 #
 
 module Couchbase
-
   class Bucket
-
-    java_import java.io.IOException
-    java_import java.net.SocketAddress
-    java_import java.net.URI
-    java_import java.net.URISyntaxException
-    java_import java.util.ArrayList
-    java_import java.util.LinkedList
-    java_import java.util.List
-    java_import java.util.concurrent.Future
-    java_import java.util.concurrent.TimeUnit
-    java_import com.couchbase.client.CouchbaseClient
-    java_import com.couchbase.client.CouchbaseConnectionFactory
-    java_import com.couchbase.client.CouchbaseConnectionFactoryBuilder
-
     include Couchbase::Operations
-    include Couchbase::Async
-
-    attr_accessor :quiet, :hostname, :port, :pool, :bucket, :username,
-                  :password, :default_ttl, :timeout, :default_format,
-                  :default_arithmetic_init, :transcoder, :transcoders
-
-    attr_reader :client, :key_prefix, :default_format
-
-    DEFAULT_OPTIONS = {
-      type:                      nil,
-      quiet:                     false,
-      hostname:                  'localhost',
-      port:                      8091,
-      pool:                      'default',
-      bucket:                    'default',
-      password:                  '',
-      engine:                    nil,
-      default_ttl:               0,
-      default_arithmetic_init:   0,
-      default_flags:             0,
-      default_format:            :document,
-      default_observe_timeout:   2_500_000,
-      on_error:                  nil,
-      on_connect:                nil,
-      timeout:                   0,
-      environment:               nil,
-      key_prefix:                nil,
-      node_list:                 nil,
-      destroying:                0,
-      connected:                 0,
-      on_connect_proc:           nil,
-      connected:                 false
-    }.freeze
-
-    # Initialize new Bucket.
-    #
-    # @since 1.0.0
-    #
-    # @overload initialize(url, options = {})
-    #   Initialize bucket using URI of the cluster and options. It is possible
-    #   to override some parts of URI using the options keys (e.g. :host or
-    #   :port)
-    #
-    #   @param [String] url The full URL of management API of the cluster.
-    #   @param [Hash] options The options for connection. See options definition
-    #     below.
-    #
-    # @overload initialize(options = {})
-    #   Initialize bucket using options only.
-    #
-    #   @param [Hash] options The options for operation for connection
-    #   @option options [Array] :node_list (nil) the list of nodes to connect
-    #     to. If specified it takes precedence over +:host+ option. The list
-    #     must be array of strings in form of host names or host names with
-    #     ports (in first case port 8091 will be used, see examples).
-    #   @option options [String] :host ("localhost") the hostname or IP address
-    #     of the node
-    #   @option options [Fixnum] :port (8091) the port of the managemenent API
-    #   @option options [String] :pool ("default") the pool name
-    #   @option options [String] :bucket ("default") the bucket name
-    #   @option options [Fixnum] :default_ttl (0) the TTL used by default during
-    #     storing key-value pairs.
-    #   @option options [Fixnum] :default_flags (0) the default flags.
-    #   @option options [Symbol] :default_format (:document) the format, which
-    #     will be used for values by default. Note that changing format will
-    #     amend flags. (see {Bucket#default_format})
-    #   @option options [String] :username (nil) the user name to connect to the
-    #     cluster. Used to authenticate on management API. The username could
-    #     be skipped for protected buckets, the bucket name will be used
-    #     instead.
-    #   @option options [String] :password (nil) the password of the user.
-    #   @option options [true, false] :quiet (false) the flag controlling if raising
-    #     exception when the client executes operations on non-existent keys. If it
-    #     is +true+ it will raise {Couchbase::Error::NotFound} exceptions. The
-    #     default behaviour is to return +nil+ value silently (might be useful in
-    #     Rails cache).
-    #   @option options [Symbol] :environment (:production) the mode of the
-    #     connection. Currently it influences only on design documents set. If
-    #     the environment is +:development+, you will able to get design
-    #     documents with 'dev_' prefix, otherwise (in +:production+ mode) the
-    #     library will hide them from you.
-    #   @option options [String] :key_prefix (nil) the prefix string which will
-    #     be prepended to each key before sending out, and sripped before
-    #     returning back to the application.
-    #   @option options [Fixnum] :timeout (2500000) the timeout for IO
-    #     operations (in microseconds)
-    #   @option options [Fixnum, true] :default_arithmetic_init (0) the default
-    #     initial value for arithmetic operations. Setting this option to any
-    #     non positive number forces creation missing keys with given default
-    #     value. Setting it to +true+ will use zero as initial value. (see
-    #     {Bucket#incr} and {Bucket#decr}).
-    #   @option options [Symbol] :engine (:default) the IO engine to use
-    #     Currently following engines are supported:
-    #     :default      :: Built-in engine (multi-thread friendly)
-    #     :libevent     :: libevent IO plugin from libcouchbase (optional)
-    #     :libev        :: libev IO plugin from libcouchbase (optional)
-    #     :eventmachine :: EventMachine plugin (builtin, but requires EM gem and ruby 1.9+)
-    #
-    # @example Initialize connection using default options
-    #   Couchbase.new
-    #
-    # @example Select custom bucket
-    #   Couchbase.new(:bucket => 'foo')
-    #   Couchbase.new('http://localhost:8091/pools/default/buckets/foo')
-    #
-    # @example Connect to protected bucket
-    #   Couchbase.new(:bucket => 'protected', :username => 'protected', :password => 'secret')
-    #   Couchbase.new('http://localhost:8091/pools/default/buckets/protected',
-    #                 :username => 'protected', :password => 'secret')
-    #
-    # @example Use list of nodes, in case some nodes might be dead
-    #   Couchbase.new(:node_list => ['example.com:8091', 'example.org:8091', 'example.net'])
-    #
-    # @raise [Couchbase::Error::BucketNotFound] if there is no such bucket to
-    #   connect to
-    #
-    # @raise [Couchbase::Error::Connect] if the socket wasn't accessible
-    #   (doesn't accept connections or doesn't respond in time)
-    #
-    # @return [Bucket]
-    #
-    def initialize(url = nil, options = {})
-      url_options = expand_url_options(url)
-
-      options = Couchbase.normalize_connection_options(options)
-
-      connection_options = DEFAULT_OPTIONS.merge(url_options).merge(options)
-
-      connection_options.each_pair do |key, value|
-        instance_variable_set("@#{key}", value)
-      end
-
-      self.password = '' if self.password.nil?
-
-      @transcoders = {
-        document: Transcoder::Document.new,
-        marshal:  Transcoder::Marshal.new,
-        plain:    Transcoder::Plain.new
-      }
-
-      connect
-    end
-
-    def quiet?
-      !!quiet
-    end
-
-    def host
-      hostname
-    end
-
-    def connect
-      uris = expand_node_list
-
-      begin
-        builder = CouchbaseConnectionFactoryBuilder.new
-        builder.setTranscoder(transcoder)
-        connection_factory = builder.buildCouchbaseConnection(uris, bucket.to_java_string, password.to_java_string)
-        @client = CouchbaseClient.new(connection_factory)
-        @connected = true
-      rescue Java::ComCouchbaseClientVbucket::ConfigurationException => e
-        fail Couchbase::Error::Auth, "Couchbase configurations are incorrect: #{e.to_s}"
-      rescue java.net.ConnectException => e
-        fail Couchbase::Error::Connect, e.to_s
-      end
-
-      self
-    end
-    alias_method :reconnect, :connect
 
-    def authority
-      "#{hostname}:#{port}"
-    end
-
-    def base_url
-      "http://#{authority}/pools"
-    end
-
-    def url
-      "http://#{authority}/pools/#{pool}/buckets/#{bucket}/"
-    end
-
-    def connected?
-      @connected
-    end
-
-    def disconnect
-      if connected? && @client.shutdown(3, TimeUnit::SECONDS)
-        @client = nil
-        @connection_factory = nil
-        @connected = false
-      else
-        fail Couchbase::Error::Connect
-      end
-    end
-
-    def transcoder
-      transcoders[default_format]
-    end
+    attr_reader :bucket
 
-    def on_connect(&block)
-      @on_connect = block
+    def initialize(bucket)
+      @bucket = bucket
     end
 
-    def on_error(&block)
-      @on_error = block
+    def async
+      @bucket.async
     end
 
-    def version
-      {}.tap do |hash|
-        @client.getVersions.to_hash.each_pair do |ip, ver|
-          hash[ip.to_s] = ver
-        end
-      end
+    def save_design_doc(name, design_doc, development = false)
+      design_doc = DesignDoc.new(name, design_doc)
+      @bucket.bucket_manager.upsert_design_document(design_doc.create, development)
     end
 
-    # Compare and swap value.
-    #
-    # @since 1.0.0
-    #
-    # Reads a key's value from the server and yields it to a block. Replaces
-    # the key's value with the result of the block as long as the key hasn't
-    # been updated in the meantime, otherwise raises
-    # {Couchbase::Error::KeyExists}. CAS stands for "compare and swap", and
-    # avoids the need for manual key mutexing. Read more info here:
-    #
-    # In asynchronous mode it will yield result twice, first for
-    # {Bucket#get} with {Result#operation} equal to +:get+ and
-    # second time for {Bucket#set} with {Result#operation} equal to +:set+.
-    #
-    # @see http://couchbase.com/docs/memcached-api/memcached-api-protocol-text_cas.html
-    #
-    # @param [String, Symbol] key
-    #
-    # @param [Hash] options the options for "swap" part
-    # @option options [Fixnum] :ttl (self.default_ttl) the time to live of this key
-    # @option options [Symbol] :format (self.default_format) format of the value
-    # @option options [Fixnum] :flags (self.default_flags) flags for this key
-    #
-    # @yieldparam [Object, Result] value old value in synchronous mode and
-    #   +Result+ object in asynchronous mode.
-    # @yieldreturn [Object] new value.
-    #
-    # @raise [Couchbase::Error::KeyExists] if the key was updated before the the
-    #   code in block has been completed (the CAS value has been changed).
-    # @raise [ArgumentError] if the block is missing for async mode
-    #
-    # @example Implement append to JSON encoded value
-    #
-    #     c.default_format = :document
-    #     c.set("foo", {"bar" => 1})
-    #     c.cas("foo") do |val|
-    #       val["baz"] = 2
-    #       val
-    #     end
-    #     c.get("foo")      #=> {"bar" => 1, "baz" => 2}
-    #
-    # @example Append JSON encoded value asynchronously
-    #
-    #     c.default_format = :document
-    #     c.set("foo", {"bar" => 1})
-    #     c.run do
-    #       c.cas("foo") do |val|
-    #         case val.operation
-    #         when :get
-    #           val["baz"] = 2
-    #           val
-    #         when :set
-    #           # verify all is ok
-    #           puts "error: #{ret.error.inspect}" unless ret.success?
-    #         end
-    #       end
-    #     end
-    #     c.get("foo")      #=> {"bar" => 1, "baz" => 2}
-    #
-    # @return [Fixnum] the CAS of new value
-    def cas(key, options = {})
-      val, flags, ver = get(key, :extended => true)
-      val = yield(val) # get new value from caller
-      set(key, val, options.merge(:cas => ver))
+    def query(design_doc, view)
+      View.new(design_doc, view, self)
     end
-    alias :compare_and_swap :cas
 
-    # Delete contents of the bucket
-    #
-    # @see http://www.couchbase.com/docs/couchbase-manual-2.0/restapi-flushing-bucket.html
-    #
-    # @since 1.2.0.beta
-    #
-    # @yieldparam [Result] ret the object with +error+, +status+ and +operation+
-    #   attributes.
-    #
-    # @raise [Couchbase::Error::Protocol] in case of an error is
-    #   encountered. Check {Couchbase::Error::Base#status} for detailed code.
-    #
-    # @return [true] always return true (see raise section)
-    #
-    # @example Simple flush the bucket
-    #   c.flush    #=> true
-    #
     def flush
-      async_flush.get
+      bucket.bucket_manager.flush
     end
-
-    def async_flush
-      @client.flush
-    end
-
-    private
-
-    def path_to_pool_and_bucket(path)
-      {}
-    end
-
-    def expand_url_options(url)
-      if url.is_a? String
-        fail ArgumentError.new unless url =~ /^http:\/\//
-        uri = URI.new(url)
-        { hostname: uri.host, port: uri.port }.merge(path_to_pool_and_bucket(uri.path))
-      elsif url.nil?
-        {}
-      else
-        url
-      end
-    end
-
-    def expand_node_list
-      if @node_list
-        Array(@node_list).map { |n| URI.new(n) }
-      else
-        Array(URI.new(base_url))
-      end
-    end
-
   end
-
 end

data/lib/couchbase/cluster.rb

@@ -1,5 +1,5 @@
-# Author:: Couchbase <info@couchbase.com>
-# Copyright:: 2011, 2012 Couchbase, Inc.
+# Author:: Mike Evans <mike@urlgonomics.com>
+# Copyright:: 2013 Urlgonomics LLC.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,100 +17,22 @@
 
 module Couchbase
 
-  class ClusterError < Error::Base; end
-
   class Cluster
 
-    java_import java.net.URI
-    java_import com.couchbase.client.clustermanager.BucketType
-    java_import com.couchbase.client.clustermanager.FlushResponse
-    java_import com.couchbase.client.clustermanager.AuthType
-
-    # Establish connection to the cluster for administration
-    #
-    # @param [Hash] options The connection parameter
-    # @option options [String] :username The username
-    # @option options [String] :password The password
-    # @option options [String] :pool ("default") The pool name
-    # @option options [String] :hostname ("localhost") The hostname
-    # @option options [String] :port (8091) The port
-    def initialize(options)
-      if options[:username].nil? || options[:password].nil?
-        raise ArgumentError, "username and password mandatory to connect to the cluster"
-      end
+    java_import com.couchbase.client.java.CouchbaseCluster
 
-      options = {
-        hostname: 'localhost',
-        port:     8091
-      }.merge(options)
+    attr_reader :cluster
 
-      cluster_uri = "http://#{options[:hostname]}:#{options[:port]}"
-
-      uri_list = Array(URI.new(cluster_uri))
-      @manager = Java::ComCouchbaseClient::ClusterManager.new(uri_list, options[:username], options[:password])
+    def initialize(hosts = 'localhost')
+      @cluster = CouchbaseCluster.create(hosts)
     end
 
-    # List available buckets
-    def list_buckets
-      @manager.listBuckets
+    def open_bucket(name = 'default', password = '')
+      Bucket.new(@cluster.open_bucket(name, password))
     end
 
-    # Delete the data bucket
-    #
-    # @param [String] name The name of the bucket
-    # @param [Hash] options
-    def delete_bucket(bucket)
-      @manager.deleteBucket(bucket)
-    end
-
-    # Create data bucket
-    #
-    # @param [String] name The name of the bucket
-    # @param [Hash] options The bucket parameters
-    # @option options [String] :bucket_type ("couchbase") The type of the
-    #   bucket. Possible values are "memcached" and "couchbase".
-    # @option options [Fixnum] :ram_quota (100) The RAM quota in megabytes.
-    # @option options [Fixnum] :replica_number (1) The number of replicas of
-    #   each document
-    # @option options [String] :auth_type ("sasl") The authentication type.
-    #   Possible values are "sasl" and "none". Note you should specify free
-    #   port for "none"
-    # @option options [Fixnum] :proxy_port The port for moxi
-    def create_bucket(name, options = {})
-      ram_quota   = options[:ram_quota] || 100
-      replicas    = options[:replica_number] || 0
-      flush       = options.fetch(:flush) { true }
-      password    = options[:password]
-      proxy_port  = options[:proxy_port]
-      auth_type   = options[:auth_type] || 'sasl'
-      bucket_type = options[:bucket_type] == 'memcached' ? BucketType::MEMCACHED : BucketType::COUCHBASE
-
-      if name == 'default'
-        @manager.createDefaultBucket(bucket_type, ram_quota, replicas, flush)
-      elsif auth == 'sasl'
-        @manager.createPortBucket(bucket_type, name, ram_quota, replicas, proxy_port, flush)
-      else
-        @manager.createNamedBucket(bucket_type, name, ram_quota, replicas, password, flush)
-      end
-      true
-    rescue Java::JavaLang::RuntimeException => e
-      raise ClusterError, e
-    end
-
-    def flush_bucket(bucket)
-      @manager.flushBucket(bucket) == FlushResponse::OK
-    end
-
-    def update_bucket(name, options)
-      # implement
-    end
-
-    def self.manage(cluster_uri, username, password, &block)
-      manager = new(cluster_uri, username, password)
-      yield manager
-    ensure
-      manager.shutdown
+    def disconnect
+      @cluster.disconnect
     end
   end
-
 end

data/lib/couchbase/configuration.rb

@@ -0,0 +1,39 @@
+module Couchbase
+
+  class Configuration
+
+    DEFAULT_CONFIG = {
+      host:     'localhost',
+      bucket:   'default',
+      password: ''
+    }
+
+    Bucket = Struct.new(:name, :password)
+
+    attr_accessor :hosts, :buckets
+
+    def initialize(config = {})
+      config = DEFAULT_CONFIG.merge(symbolize_keys(config))
+      @hosts = Array(config[:hosts] || config[:host] || config[:hostname])
+
+      if config[:buckets]
+        @buckets = config[:buckets].map do |b|
+          b = symbolize_keys(b)
+          Bucket.new(b[:name], b[:password])
+        end
+      else
+        @buckets = [Bucket.new(config[:bucket], config[:password])]
+      end
+    end
+
+    private
+
+    def symbolize_keys(old_hash)
+      {}.tap do |hash|
+        old_hash.each_pair do |key, value|
+          hash[key.to_sym] = value
+        end
+      end
+    end
+  end
+end