sqlcached_client 0.1.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c1d7081154f231b08f1e85a1fa5a7104fc0fd3fd
-  data.tar.gz: e9417935129734d01bb8963812dc7bad64f06d1d
+  metadata.gz: aeb070751a16b6997e533f2cca908ab9de07e1b4
+  data.tar.gz: c4bb3a0d14aab39201c4eb037d3d3c47e84c6786
 SHA512:
-  metadata.gz: 5209a595a579fe676cafb93a560c3029a109a4bfc68aac344e909191fbae6b8693aa5d51b39db251bca2c59bed59a6323f103ca57d6ecb3f687858ba33af1d28
-  data.tar.gz: 6114598d416b573c17c69bc49084f760ac0aa06f126bae6061c8dabb1f2179b4e851de3505be98fb37056953d83c5a983d7bd785a4f426c3fd32f8fa5523dbd0
+  metadata.gz: 684c26e56298b9fb7f69375371849359cfc5a2222a7f1c2a82728be476c0dfa236d77e9ef3e544b063ec2878df4cccd1a8579d4306047d0316fe398deec5ada6
+  data.tar.gz: fd4181382f54cdddac87c174c199ddf316301d71ed1115967712ddb3a689bbc3d75b304c7d8fdd9865a2301d175c8192ddbdc31d74f00c22d9ce6f7b13c5d36d

data/lib/sqlcached_client/entity.rb

@@ -1,17 +1,19 @@
 require 'sqlcached_client/resultset'
 require 'sqlcached_client/server'
 require 'sqlcached_client/arel'
+require 'sqlcached_client/tree_visitor'
 
 module SqlcachedClient
   class Entity
     extend Arel
+    extend TreeVisitor
 
     attr_reader :attributes
 
     # @param attributes [Hash]
     def initialize(attributes)
       @attributes = attributes
-      self.class.define_readers(attributes.keys)
+      define_readers(attributes.keys)
     end
 
 
@@ -74,7 +76,7 @@ module SqlcachedClient
         request =
           begin
             paramIterator = -> (parameter) {
-              server.format_request(query_id, query, parameter, cache)
+              server.build_request_item(query_id, query, parameter, cache)
             }
             if params.is_a?(Array)
               params.map { |p| instance_exec(p, &paramIterator) }
@@ -87,7 +89,7 @@ module SqlcachedClient
         else
           data =
             server.session do |server, session|
-              server.run_query(session, server.build_request_body(
+              server.run_query(session, server.build_request(
                 request.is_a?(Array) ? request : [request]
               ))
             end
@@ -120,10 +122,10 @@ module SqlcachedClient
         association = -> (this, foreign_entity, join_attributes, dry_run) {
           foreign_entity.where(Hash[ join_attributes.map do |attr_names|
             attr_value =
-              if attr_names[1].is_a?(Symbol)
-                this.send(attr_names[1])
-              else
+              if this.join_constant_value?(attr_names[1])
                 attr_names[1]
+              else
+                this.send(attr_names[1])
               end
             [ attr_names[0], attr_value ]
           end ], dry_run)
@@ -137,11 +139,11 @@ module SqlcachedClient
           # get the associated entity class
           foreign_entity = Module.const_get(foreign_class_name)
           if dry_run
-            association.call(self, foreign_entity, join_attributes, true)
+            association.(self, foreign_entity, join_attributes, true)
           else
             instance_variable_get(memoize_var) ||
               instance_variable_set(memoize_var,
-                association.call(self, foreign_entity, join_attributes, false))
+                association.(self, foreign_entity, join_attributes, false))
           end
         end
         # define the setter method
@@ -152,7 +154,11 @@ module SqlcachedClient
             Resultset.new(foreign_entity, array))
         end
         # save the newly created association
-        register_association(accessor_name)
+        register_association(OpenStruct.new({
+          accessor_name: accessor_name.to_sym,
+          class_name: foreign_class_name,
+          join_attributes: join_attributes
+        }))
       end
 
       # Defines a 'has_one' relationship. See 'has_many' for the available
@@ -166,25 +172,19 @@ module SqlcachedClient
         end
       end
 
+
       def registered_associations
         @registered_associations || []
       end
 
-      # Define the readers for the attribute names specified
-      # @param attr_names [Array]
-      def define_readers(attr_names)
-        if @_readers_defined.nil?
-          attr_names.each do |attr_name|
-            if method_defined?(attr_name)
-              raise "Cannot define accessor: #{attr_name}"
-            else
-              define_method(attr_name) do
-                attributes[attr_name]
-              end
-            end
-          end
-          @_readers_defined = true
-        end
+
+      def association_names
+        registered_associations.map(&:accessor_name)
+      end
+
+
+      def is_an_association?(name)
+        association_names.include?(name.to_sym)
       end
 
       # Configures the caching timing if a parameter is provided, otherwise
@@ -203,39 +203,132 @@ module SqlcachedClient
         end
       end
 
+
+      def build_query_tree
+        # returns the subtrees (associated classes) of the given entity class
+        get_associated_entities = -> (entity) {
+          entity.registered_associations.map do |a|
+            Module.const_get(a.class_name)
+          end
+        }
+
+        # function to apply to each node while traversing the tree
+        visit = -> (entity, parent, index) {
+          entity.server.build_request_item(
+            entity.query_id,
+            entity.query,
+            # query_params
+            if parent
+              Hash[
+                parent.registered_associations[index].join_attributes.map do |j_attr|
+                  [ j_attr[0], {
+                    value: j_attr[1],
+                    type:
+                      if entity.join_constant_value?(j_attr[1])
+                        'constant'
+                      else
+                        'parent_attribute'
+                      end
+                  } ]
+                end
+              ]
+            else
+              nil
+            end,
+            entity.cache
+          ).merge(associations: entity.association_names)
+        }
+
+        # builds the result of a visit step
+        result_builder = -> (root, subtrees) {
+          { root: root, subtrees: subtrees }
+        }
+
+        # traverse the tree
+        visit_in_preorder(get_associated_entities, visit, result_builder)
+      end
+
+
+      def join_constant_value?(value)
+        !value.is_a?(Symbol)
+      end
+
+      # Like 'where' but loads every associated entity recursively at any level,
+      #   with only one interaction with the server
+      # @param root_conditions [Array]
+      def load_tree(root_conditions)
+        server.session do |server, session|
+          server.run_query(session, server.build_tree_request(
+            build_query_tree, root_conditions))
+        end
+      end
+
     private
 
-      def register_association(association_name)
+      def register_association(association_struct)
         @registered_associations ||= []
-        @registered_associations << association_name.to_sym
+        @registered_associations << association_struct
       end
     end # class << self
 
+    # Define the readers for the attribute names specified
+    # @param attr_names [Array]
+    def define_readers(attr_names)
+      attr_names.each do |attr_name|
+        if respond_to?(attr_name)
+          if self.class.is_an_association?(attr_name)
+            # lazy instantiate associated records
+            association_writer = method("#{attr_name}=")
+            association_reader = method(attr_name)
+            define_singleton_method(attr_name) do
+              association_writer.(attributes[attr_name])
+              association_reader.()
+            end
+          else
+            raise "Cannot define accessor: #{attr_name}"
+          end
+        else
+          define_singleton_method(attr_name) do
+            attributes[attr_name]
+          end
+        end
+      end
+    end
+
+
+    def join_constant_value?(value)
+      self.class.join_constant_value?(value)
+    end
+
+
     def get_association_requests
-      self.class.registered_associations.map do |a_name|
+      self.class.association_names.map do |a_name|
         send(a_name, true)
       end
     end
 
+
     def set_associations_data(associations_data)
-      self.class.registered_associations.map.with_index do |a_name, i|
+      self.class.association_names.map.with_index do |a_name, i|
         send("#{a_name}=", associations_data[i])
       end
     end
 
+
     def get_associations
-      self.class.registered_associations.map do |a_name|
+      self.class.association_names.map do |a_name|
         send(a_name)
       end
     end
 
+
     def build_associations(max_depth = false)
       Resultset.new(self.class, [self]).build_associations(max_depth)
     end
 
+
     def to_h
       attributes
     end
-
   end # class Entity
 end

data/lib/sqlcached_client/resultset.rb

@@ -29,7 +29,7 @@ module SqlcachedClient
             next_batch =
               server.run_query(
                 session,
-                server.build_request_body(
+                server.build_request(
                   batch
                 )
               ).map.with_index do |resultset_data, i|

data/lib/sqlcached_client/server.rb

@@ -6,6 +6,7 @@ module SqlcachedClient
   class Server
     attr_reader :host, :port
 
+    # @param config [Hash] something like { host: 'localhost', port: 8081 }
     def initialize(config)
       @host = config[:host]
       @port = config[:port]
@@ -25,7 +26,7 @@ module SqlcachedClient
       if 200 == resp.code.to_i
         resp_body
       else
-        raise "Got http response #{resp.code} from server - #{resp_body.inspect}"
+        raise "Got HTTP response #{resp.code} from server - #{resp_body.inspect}"
       end
     end
 
@@ -44,28 +45,45 @@ module SqlcachedClient
       end
     end
 
-
-    def build_request_body(ary)
+    # Builds a 'standard' request body
+    # @param ary [Array]
+    # @return [Hash]
+    def build_request(ary)
       { batch: ary }
     end
 
+    # Builds a request body suitable for a 'tree' request
+    # @param tree [Hash]
+    # @param root_parameters [Array] a vector of actual condition parameters
+    #   for the root query
+    def build_tree_request(tree, root_parameters)
+      { tree: tree, root_parameters: root_parameters }
+    end
 
-    def format_request(query_id, query_template, params, cache)
+    # Formats the parameters passed in the way the server expects
+    # @param query_id [String] unique identifier for this query
+    # @param query_template [String] the sql template
+    # @param params [Hash] the parameter to fill the template
+    # @param cache [Integer] number of seconds the data should be cached
+    # @return [Hash]
+    def build_request_item(query_id, query_template, params, cache)
       {
-        queryId: query_id,
-        queryTemplate: query_template,
-        queryParams: params,
+        query_id: query_id,
+        query_template: query_template,
+        query_params: params,
         cache: cache
       }
     end
 
-
+    # @return [Net::HTTP] an http session on the server
     def get_session
       url = server_url
       Net::HTTP.start(url.host, url.port)
     end
 
-
+    # Starts an http session yielding the block passed. Closes the connession
+    # when the block returns.
+    # @return the value returned by the block
     def session
       s = get_session
       ret_value = yield(self, s) if block_given?

data/lib/sqlcached_client/tree_visitor.rb

@@ -0,0 +1,19 @@
+module SqlcachedClient
+  module TreeVisitor
+
+    # @param get_subtrees [Proc]
+    # @param visit [Proc]
+    # @param result_builder [Proc]
+    # @param parent [Object]
+    # @param index [Integer]
+    def visit_in_preorder(get_subtrees, visit, result_builder,
+        parent = nil, index = nil)
+      result_builder.(
+        visit.(self, parent, index),
+        get_subtrees.(self).map.with_index do |item, i|
+          item.visit_in_preorder(get_subtrees, visit, result_builder, self, i)
+        end
+      )
+    end
+  end
+end

data/lib/sqlcached_client/version.rb

@@ -1,3 +1,3 @@
 module SqlcachedClient
-  VERSION = "0.1.2"
+  VERSION = "0.2.0"
 end

data/spec/sqlcached_client/entity_spec.rb

@@ -100,8 +100,8 @@ describe SqlcachedClient::Entity do
 
     context "if dry_run" do
       it "should return the request that would be sent to the server" do
-        entity_class.server(double(format_request: "this is the request"))
-        expect(entity_class.server).to receive(:format_request).with("foo", "bar", { baz: "biz" }, true)
+        entity_class.server(double(build_request_item: "this is the request"))
+        expect(entity_class.server).to receive(:build_request_item).with("foo", "bar", { baz: "biz" }, true)
         expect(entity_class.where({ baz: "biz" }, true)).to eq("this is the request")
       end
     end
@@ -109,11 +109,11 @@ describe SqlcachedClient::Entity do
     context "if not dry_run" do
       it "should create a new ResultSet" do
         entity_class.server(double(
-          format_request: "this is the request",
-          build_request_body: "request body",
+          build_request_item: "this is the request",
+          build_request: "request body",
           session: [ [{ key: "value" }], [{ key: "value" }] ]
         ))
-        expect(entity_class.server).to receive(:format_request).with(
+        expect(entity_class.server).to receive(:build_request_item).with(
           "foo", "bar", { baz: "biz" }, true)
         expect(entity_class.where({ baz: "biz" })).to be_instance_of(
           SqlcachedClient::Resultset)
@@ -160,4 +160,25 @@ describe SqlcachedClient::Entity do
       expect(entity.to_h).to eq(h)
     end
   end
+
+
+  describe :join_constant_value? do
+    context "if value is a Symbol" do
+      it "should be false" do
+        expect(SqlcachedClient::Entity.join_constant_value?(:foo)).to eq(false)
+      end
+    end
+
+    context "if value is not a Symbol" do
+      it "should be true" do
+        expect(SqlcachedClient::Entity.join_constant_value?('bar')).to eq(true)
+        expect(SqlcachedClient::Entity.join_constant_value?(1)).to eq(true)
+      end
+    end
+  end
+
+
+  describe :build_query_tree do
+    pending
+  end
 end

data/spec/sqlcached_client/server_spec.rb

@@ -13,19 +13,28 @@ describe SqlcachedClient::Server do
   end
 
 
-  describe :build_request_body do
+  describe :build_request do
     it "should put the passed value into an hash" do
-      expect(server.build_request_body("foo")).to eq({ batch: "foo" })
+      expect(server.build_request("foo")).to eq({ batch: "foo" })
     end
   end
 
 
-  describe :format_request do
+  describe :build_tree_request do
+    it "should be an Hash with 'tree' and 'root_parameters' keys" do
+      expect(server.build_tree_request('tree', 'root')).to eq({
+        tree: 'tree', root_parameters: 'root'
+      })
+    end
+  end
+
+
+  describe :build_request_item do
     it "should be an hash with id, template, params keys" do
-      expect(server.format_request("foo", "bar", "baz", "cache")).to eq({
-        queryId: "foo",
-        queryTemplate: "bar",
-        queryParams: "baz",
+      expect(server.build_request_item("foo", "bar", "baz", "cache")).to eq({
+        query_id: "foo",
+        query_template: "bar",
+        query_params: "baz",
         cache: "cache"
       })
     end

data/spec/sqlcached_client/tree_visitor_spec.rb

@@ -0,0 +1,55 @@
+require 'sqlcached_client/tree_visitor'
+
+describe SqlcachedClient::TreeVisitor do
+
+  let(:fake_class) do
+    Class.new(Object) do
+      include SqlcachedClient::TreeVisitor
+
+      attr_reader :subtrees, :depth
+
+      def initialize(depth, subtrees)
+        @depth = depth; @subtrees = subtrees
+      end
+    end
+  end
+
+  let(:fake_tree) do
+    fake_class.new(0, [
+      fake_class.new(1, [
+        fake_class.new(2, [
+            fake_class.new(3, []), fake_class.new(3, [])
+          ])
+        ]),
+      fake_class.new(1, [])
+    ])
+  end
+
+  let(:result_builder) do
+    -> (root, subtrees) { [root, subtrees] }
+  end
+
+
+  describe :visit_in_preorder do
+
+    context "with an empty tree" do
+      it "is expected to visit the root element only" do
+        tree = double(element: 'root', subtrees: [])
+        tree.extend(SqlcachedClient::TreeVisitor)
+        values = []
+        tree.visit_in_preorder(:subtrees.to_proc,
+          -> (el, parent, index) { values << el.element },
+          result_builder)
+        expect(values).to eq(['root'])
+      end
+    end
+
+    it "is expected to be 0, 1, 2, 3, 3, 1" do
+      values = []
+      fake_tree.visit_in_preorder(:subtrees.to_proc,
+        -> (item, parent, index) { values << item.depth },
+        result_builder)
+      expect(values).to eq([0, 1, 2, 3, 3, 1])
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sqlcached_client
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.0
 platform: ruby
 authors:
 - Roberto Maestroni
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-03 00:00:00.000000000 Z
+date: 2015-06-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -125,10 +125,12 @@ files:
 - lib/sqlcached_client/entity.rb
 - lib/sqlcached_client/resultset.rb
 - lib/sqlcached_client/server.rb
+- lib/sqlcached_client/tree_visitor.rb
 - lib/sqlcached_client/version.rb
 - spec/sqlcached_client/entity_spec.rb
 - spec/sqlcached_client/resultset_spec.rb
 - spec/sqlcached_client/server_spec.rb
+- spec/sqlcached_client/tree_visitor_spec.rb
 - sqlcached_client.gemspec
 homepage: https://github.com/rmaestroni/sqlcached_client
 licenses:
@@ -158,3 +160,4 @@ test_files:
 - spec/sqlcached_client/entity_spec.rb
 - spec/sqlcached_client/resultset_spec.rb
 - spec/sqlcached_client/server_spec.rb
+- spec/sqlcached_client/tree_visitor_spec.rb