sqlcached_client 0.0.2 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 76ca46c57afc585a8a3ba673e64992b765534fde
-  data.tar.gz: 2be70c7d54517dd4a3d3bedb833572592b3bfea0
+  metadata.gz: 30b7e7df7003436bc67762203e5e3fdd982be9b9
+  data.tar.gz: e9fbb528788728392c7b5a6b879a38230beafd11
 SHA512:
-  metadata.gz: 6f797a555a1f56561da3a56c535ddd8f0822e6636cfa5d3b2bc648cff9e99f51cc0d8e215c1aca398ba381e5ed87b5f24f64b5cebd59ddec6b688fa475aef895
-  data.tar.gz: cfa1fa922a25c58a327361e0561b7fd5d4391562f4f125ac32cd16bb1a7de6252b2db9655767843847ae448f6550567152f74fea1000e498b6dba11776bae0a1
+  metadata.gz: 084112afa0b779ff0772ef3fcdbe43e12e3d5fbeea51dc7b177d5dfef29d0a3cf37cc9df665493d1c00450b96d77ed8fa77088ff74bf5999f539cdf4f33986ec
+  data.tar.gz: cd72f5a608e867d7defdcadfa37b42757bb022af05273d853cb472d343f1614bbfd117613bc1b2bbdb5a3f93e6d4a2ad6723d3edaaf0183d1ca3c4e4459b9a20

data/lib/sqlcached_client/arel.rb

@@ -0,0 +1,61 @@
+require 'singleton'
+require 'arel'
+require 'active_record'
+require 'nulldb'
+
+module SqlcachedClient
+  module Arel
+
+    # Builds a SQL query executing the Arel statements in the given block.
+    # @param tables_map [Hash] in the form of
+    #   { :t1 => [:par1, :par2], :t2 => :par3, :t3 => nil }
+    # @param arel_block [Proc]
+    # @return [Arel] an object that responds to 'to_sql'
+    def build_arel(tables_map, arel_block)
+      table_names = tables_map.keys
+      # attributes of this struct returns Arel tables named as the attribute
+      context = Struct.new(*table_names).new(
+        *table_names.map do |t_name|
+          ArelWrapper.arel_module::Table.new(t_name)
+        end
+      )
+      # build an Arel object evaluating the block if any
+      arel_q =
+        if arel_block
+          context.instance_eval(&arel_block)
+        else
+          # no block given, add the default SELECT *
+          context.send(tables_map.keys.first).project(
+            ArelWrapper.arel_module.sql('*'))
+        end
+      # add the 'where' conditions passed as parameters (values in tables_map)
+      tables_map.inject(arel_q) do |query_acc, item|
+        t_name, parameters = item
+        table = context.send(t_name)
+        parameters ||= []
+        parameters = [parameters] if !parameters.respond_to?(:inject)
+        parameters.inject(query_acc) do |arel, param|
+          arel.where(table[param].eq("{{ #{param} }}"))
+        end
+      end
+    end # method build_arel
+  end # module Arel
+
+private
+
+  class ArelWrapper
+    include Singleton
+
+    def initialize
+      ::Arel::Table.engine = ::ActiveRecord::Base.establish_connection(
+        adapter: :nulldb)
+    end
+
+    class << self
+      def arel_module
+        instance
+        ::Arel
+      end
+    end
+  end # class ArelWrapper
+end

data/lib/sqlcached_client/entity.rb

@@ -1,16 +1,17 @@
-require 'sqlcached_client/hash_struct'
 require 'sqlcached_client/resultset'
 require 'sqlcached_client/server'
+require 'sqlcached_client/arel'
 
 module SqlcachedClient
-  class Entity < HashStruct
+  class Entity
+    extend Arel
 
-    attr_reader :attribute_names
+    attr_reader :attributes
 
     # @param attributes [Hash]
     def initialize(attributes)
-      @attribute_names = attributes.keys
-      super(attributes)
+      @attributes = attributes
+      self.class.define_readers(attributes.keys)
     end
 
 
@@ -24,8 +25,22 @@ module SqlcachedClient
 
       # Sets the query of this entity if a parameter is provided, otherwise
       # returns the value previously set.
-      def query(sql_string = nil)
-        sql_string.nil? ? @query : @query = sql_string.strip
+      def query(*args, &block)
+        if args.empty?
+          @query
+        else
+          if args[0].is_a?(String)
+            @query = args[0].strip
+          else
+            @query = build_arel(
+              args.inject({}) do |acc, param|
+                acc.merge(
+                  param.is_a?(Hash) ? param : Hash[ [[param, nil]] ]
+                )
+              end,
+              block).to_sql
+          end
+        end
       end
 
       # Configures the server of this entity if a parameter is provided,
@@ -56,7 +71,7 @@ module SqlcachedClient
       # Runs the entity query with the provided parameters
       # @return [Resultset]
       def where(params, dry_run = false)
-        request = server.format_request(query_id, query, params)
+        request = server.format_request(query_id, query, params, cache)
         if dry_run
           request
         else
@@ -143,6 +158,39 @@ module SqlcachedClient
         @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
+      end
+
+      # Configures the caching timing if a parameter is provided, otherwise
+      # returns the value set in the current class or in a superclass.
+      # Default value is true.
+      def cache(seconds = nil)
+        if seconds.nil?
+          @cache ||
+            if (superclass = ancestors[1]).respond_to?(:cache)
+              superclass.cache
+            else
+              true
+            end
+        else
+          @cache = seconds
+        end
+      end
+
     private
 
       def register_association(association_name)
@@ -174,8 +222,7 @@ module SqlcachedClient
     end
 
     def to_h
-      @_to_h ||=
-        Hash[ attribute_names.map { |a_name| [a_name, send(a_name)] } ]
+      attributes
     end
 
   end # class Entity

data/lib/sqlcached_client/server.rb

@@ -50,11 +50,12 @@ module SqlcachedClient
     end
 
 
-    def format_request(query_id, query_template, params)
+    def format_request(query_id, query_template, params, cache)
       {
         queryId: query_id,
         queryTemplate: query_template,
-        queryParams: params
+        queryParams: params,
+        cache: cache
       }
     end
 

data/lib/sqlcached_client/version.rb

@@ -1,3 +1,3 @@
 module SqlcachedClient
-  VERSION = "0.0.2"
+  VERSION = "0.1.0"
 end

data/spec/sqlcached_client/entity_spec.rb

@@ -5,8 +5,16 @@ describe SqlcachedClient::Entity do
 
   describe :initialize do
     it "should record the attribute names" do
-      e = SqlcachedClient::Entity.new({ foo: 'bar', baz: 'biz' })
-      expect(e.attribute_names).to eq([:foo, :baz])
+      h = { foo: 'bar', baz: 'biz' }
+      e = Class.new(SqlcachedClient::Entity).new(h)
+      expect(e.attributes).to eq(h)
+    end
+
+    it "should define readers methods named as attributes.keys" do
+      entity_class = Class.new(SqlcachedClient::Entity)
+      entity = entity_class.new(foo: 'bar', baz: 'biz')
+      expect(entity.foo).to eq('bar')
+      expect(entity.baz).to eq('biz')
     end
   end
 
@@ -93,7 +101,7 @@ 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" })
+        expect(entity_class.server).to receive(:format_request).with("foo", "bar", { baz: "biz" }, true)
         expect(entity_class.where({ baz: "biz" }, true)).to eq("this is the request")
       end
     end
@@ -106,7 +114,7 @@ describe SqlcachedClient::Entity do
           session: [[{ key: "value" }], 2, 3]
         ))
         expect(entity_class.server).to receive(:format_request).with(
-          "foo", "bar", { baz: "biz" })
+          "foo", "bar", { baz: "biz" }, true)
         expect(entity_class.where({ baz: "biz" })).to be_instance_of(
           SqlcachedClient::Resultset)
       end
@@ -145,6 +153,11 @@ describe SqlcachedClient::Entity do
 
 
   describe :to_h do
-    pending
+    it "should return attributes" do
+      entity_class = Class.new(SqlcachedClient::Entity)
+      h = { foo: 'bar', baz: 'biz' }
+      entity = entity_class.new(h)
+      expect(entity.to_h).to eq(h)
+    end
   end
 end

data/spec/sqlcached_client/resultset_spec.rb

@@ -1,5 +1,4 @@
 require 'sqlcached_client/resultset'
-require 'sqlcached_client/hash_struct'
 
 describe SqlcachedClient::Resultset do
 
@@ -12,9 +11,9 @@ describe SqlcachedClient::Resultset do
 
     context "when passed entities are hashes" do
       it "should map them to instances of the entity class provided" do
-        r = SqlcachedClient::Resultset.new(SqlcachedClient::HashStruct,
+        r = SqlcachedClient::Resultset.new(SqlcachedClient::Entity,
           [{ foo: 'bar' }] * 3)
-        expect(r.entities[0]).to be_instance_of(SqlcachedClient::HashStruct)
+        expect(r.entities[0]).to be_instance_of(SqlcachedClient::Entity)
       end
     end
 

data/spec/sqlcached_client/server_spec.rb

@@ -22,10 +22,11 @@ describe SqlcachedClient::Server do
 
   describe :format_request do
     it "should be an hash with id, template, params keys" do
-      expect(server.format_request("foo", "bar", "baz")).to eq({
+      expect(server.format_request("foo", "bar", "baz", "cache")).to eq({
         queryId: "foo",
         queryTemplate: "bar",
-        queryParams: "baz"
+        queryParams: "baz",
+        cache: "cache"
       })
     end
   end

data/sqlcached_client.gemspec

@@ -19,6 +19,9 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_dependency "activesupport", "~> 4.2"
+  spec.add_dependency "arel", "~> 6.0"
+  spec.add_dependency "activerecord", "~> 4.2"
+  spec.add_dependency "activerecord-nulldb-adapter", "~> 0.3"
 
   spec.add_development_dependency "bundler", "~> 1.6"
   spec.add_development_dependency "rake"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sqlcached_client
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.0
 platform: ruby
 authors:
 - Roberto Maestroni
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-07 00:00:00.000000000 Z
+date: 2015-05-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -24,6 +24,48 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '4.2'
+- !ruby/object:Gem::Dependency
+  name: arel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+- !ruby/object:Gem::Dependency
+  name: activerecord-nulldb-adapter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -79,13 +121,12 @@ files:
 - README.md
 - Rakefile
 - lib/sqlcached_client.rb
+- lib/sqlcached_client/arel.rb
 - lib/sqlcached_client/entity.rb
-- lib/sqlcached_client/hash_struct.rb
 - lib/sqlcached_client/resultset.rb
 - lib/sqlcached_client/server.rb
 - lib/sqlcached_client/version.rb
 - spec/sqlcached_client/entity_spec.rb
-- spec/sqlcached_client/hash_struct_spec.rb
 - spec/sqlcached_client/resultset_spec.rb
 - spec/sqlcached_client/server_spec.rb
 - sqlcached_client.gemspec
@@ -115,6 +156,5 @@ specification_version: 4
 summary: A Ruby client for sqlcached
 test_files:
 - spec/sqlcached_client/entity_spec.rb
-- spec/sqlcached_client/hash_struct_spec.rb
 - spec/sqlcached_client/resultset_spec.rb
 - spec/sqlcached_client/server_spec.rb

data/lib/sqlcached_client/hash_struct.rb

@@ -1,70 +0,0 @@
-module SqlcachedClient
-  # Maps recursively hashes into objects with lazy evaluation. For example
-  #
-  #  hs = HashStruct.new({
-  #    a: ['foo', { a1: [{ a2: 'one' }, 'two', 'three'] }, 'bar'],
-  #    b: 'baz',
-  #    c: 4,
-  #    d: { d1: { d2: { d3: 'hi' } } }
-  #  })
-  #    # => #<HashStruct:0x0000000f188008>
-  #
-  #  hs.b
-  #    # => "baz"
-  #
-  #  hs.c
-  #    # => 4
-  #
-  #  hs.a
-  #    # => ["foo", #<HashStruct:0x0000000f1dc798>, "bar"]
-  #
-  #  hs.a[1].a1
-  #    # => [#<HashStruct:0x0000000f275ce0>, "two", "three"]
-  #
-  #  hs.a[1].a1[0].a2
-  #    # => "one"
-  #
-  #  # values are memoized
-  #  hs
-  #    # => #<HashStruct:0x0000000f188008
-  #    #  @_a=["foo", #<HashStruct:0x0000000f1dc798 @_a1=[#<HashStruct:0x0000000f275ce0 @_a2="one">, "two", "three"]>, "bar"],
-  #    #  @_b="baz",
-  #    #  @_c=4>
-  class HashStruct
-
-    def initialize(hash)
-      hash.each do |key, value|
-        define_singleton_method(key.to_sym, &HashStruct.build(value, key))
-      end
-    end
-
-    class << self
-
-      # @return [Proc]
-      def build(value, accessor_name = nil)
-        lambda =
-          if value.is_a?(Hash)
-            -> (aself, value) { HashStruct.new(value) }
-          elsif value.is_a?(Array)
-            -> (aself, value) {
-              value.map { |item| aself.instance_eval(&HashStruct.build(item)) }
-            }
-          else
-            -> (aself, value) { value }
-          end
-        if !accessor_name.nil?
-          memoize_v = "@_#{accessor_name}"
-          Proc.new {
-            if instance_variable_defined?(memoize_v)
-              instance_variable_get(memoize_v)
-            else
-              instance_variable_set(memoize_v, lambda.call(self, value))
-            end
-          }
-        else
-          Proc.new { lambda.call(self, value) }
-        end
-      end
-    end # class << self
-  end # class HashStruct
-end

data/spec/sqlcached_client/hash_struct_spec.rb

@@ -1,26 +0,0 @@
-require 'sqlcached_client/hash_struct'
-
-RSpec.describe SqlcachedClient::HashStruct do
-  let(:hash_struct) do
-    SqlcachedClient::HashStruct.new({
-      a: ['foo', { a1: [{ a2: 'one' }, 'two', 'three'] }, 'bar'],
-      b: 'baz',
-      c: 4,
-      d: { d1: { d2: { d3: 'hi' } } }
-    })
-  end
-
-  it "should map keys into methods" do
-    [:a, :b, :c, :d].each do |m|
-      expect(hash_struct.respond_to?(m)).to eq(true)
-    end
-  end
-
-  it "should map recoursively" do
-    ary = hash_struct.a
-    expect(ary[0]).to eq('foo')
-    expect(ary[1].a1[0].a2).to eq('one')
-    expect(hash_struct.d.d1.d2.d3).to eq('hi')
-    expect(hash_struct.c).to eq(4)
-  end
-end