static-record 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4d06c5fc59b117a47f86a218489bd6d95f68cfbe
-  data.tar.gz: 68da7ab138c5dbd25db2cbd359acc30296f0eb16
+  metadata.gz: 54e3e66a230098bdc375ec07c84e7a7d266872df
+  data.tar.gz: 461d0be8afac337dc13b5cd68fa62729bf2c3842
 SHA512:
-  metadata.gz: 5c2535dc8d88779a4d1489dc21dfd8a3c00ef13ff6c7d98869b1c87eb30c68edba56d9d01529cc17f582e946969fff2ff26858d38cdf7e5c37e1344febc8b1b1
-  data.tar.gz: 46ccc4996e2c053e29e153cb8101c44b3aaa58e5a6b4cf1e14a37404f5f36cf8bf24aea4bc1d5224239b411bc7817f891b03a26a5f494a7a696c7262bd6b68d5
+  metadata.gz: 835d40e2bf9e440641cf082d2ba9b9ba33ffbc9bca037e92714fffeaef83ff718c661cf26f74a5d14ca02fc2c43eb69cb35fd051a6000bc4c6bc70a7a72f961b
+  data.tar.gz: 5c6e71af8b1698e0bd03fceb0d9705f3d88815d9a143eac21586fdaa8e37ed78be71ac61cc820956b3d382fda5aab904437b8afc55d8e2b2ba9cb50ab9d15f03

data/README.rdoc

@@ -26,7 +26,7 @@ The 'require' part is important so that Rails autoloads the library correctly.
 Create your base class inheriting from StaticRecord::Base.
 
   class Article < StaticRecord::Base
-    # Declare in which SQLite3 file "articles" will be store (db/static_<table>.sqlite3)
+    # Declare in which table Articles will be store (always in file db/static_records.sqlite3)
     table       :articles
 
     # Declare at which path "article" files can be found
@@ -37,23 +37,24 @@ Create your base class inheriting from StaticRecord::Base.
     primary_key :name
 
     # You can specify default values for each column of your static records
-    # Just create a method with name: default_<attribute_name>
-    def default_author
+    # Just create a class method with name: default_<attribute_name>
+    def self.default_author
       'Default author'
     end
 
     # You can override any attribute value
-    # Just create a method with name: override_<attribute_name>
-    def override_cover(cover)
+    # Just create a class method with name: override_<attribute_name>
+    def self.override_cover(cover)
       return cover if cover.to_s.include?('/')
       Rails.root.join('public', 'default_cover_path', cover)
     end
 
     # Specify which "article" attributes can be queried over with their types
-    columns     name:   :string,
-                author: :string,
-                rank:   :integer,
-                cover:  :string
+    columns     name:     :string,
+                author:   :string,
+                rank:     :integer,
+                cover:    :string,
+                category  :static_record
   end
 
 At each application startup, an SQLite3 database will be created to store this class' children.
@@ -63,6 +64,7 @@ Available column types are
 - :integer
 - :boolean
 - :float
+- :static_record
 
 === Child class
 
@@ -75,6 +77,10 @@ Create has many child class as you want.
     attribute :rank, 2
     attribute :cover, Rails.root.join('public', 'articles', 'one.jpg')
 
+    # Define the references to other StaticRecords
+    # These ones can be queried over after a jointure
+    reference :category, Category.find('Category One')
+
     # Your class can be used as any other Ruby class
     def initialize
       @an_instance_variable
@@ -94,25 +100,51 @@ In your code, you can perform queries like this one:
 
 Article.where(name: 'Article Two').or.where('rank >= 2').limit(2).offset(3)
 
-I tried to implement as many SQL functions wrappers that ActiveRecord provides as I could.
+I tried to implement as much of ActiveRecord's query interface as I could.
 
-There is still a lot of work before everything is available, but I chose to release the 1.0.0.pre nevertheless.
+There is still a lot of work before everything is available, but I chose to release the gem nevertheless.
 
 Here is a full list:
 * where
-  * supports Hash -> where(name: 'Name', author: 'Author')
-  * supports String -> where("name = 'Name'") or where("name = ?", 'Name') or where("name = :name", name: 'Name')
+  * Article.where(name: 'Article One', author: 'The author')
+  * Article.where(name: ['Article One', 'Article Two'])
+  * Article.where(name: 'Article One').where(author: 'The author')
+  * Article.where("name = 'Article One'")
+  * Article.where("name = ?", 'Article One')
+  * Article.where("name = :name", name: 'Article One')
 * find (only if a primary key has been set)
+  * Article.find('Article One')
 * find_by
+  * Article.find_by(author: 'The author')
+* joins
+  * Article.joins(:categories).where("categories.name = 'Category One'")
 * not
+  * Article.where.not(author: 'The author')
 * or
+  * Article.where(author: 'The author').or.where(author: 'Another author')
+  * Article.where.not(name: 'Article One').or.where.not(author: 'The author')
 * all
+  * Article.where(author: 'The author').all
+  * Article.all
 * take
+  * Article.take
+  * Article.take(3)
 * first
+  * Article.first
+  * Article.first(3)
 * last
+  * Article.last
+  * Article.last(3)
 * limit
+  * Article.limit(5)
 * offset
+  * Article.limit(3).offset(2)
 * order
+  * Article.order(:rank) # Use ASC ordering
+  * Article.order([:rank, :name]) # Use ASC ordering for both columns
+  * Article.order(rank: :asc)
+  * Article.order(rank: :desc, name: :asc)
+  * Article.order("rank DESC")
 
 == IDs
 
@@ -122,6 +154,8 @@ As the database is recreated at each application startup and IDs depend on the i
 
 == References
 
+=== ActiveRecord
+
 A migration helper allows your ActiveRecord models to reference a StaticRecord.
 
 In a migration, use:
@@ -153,6 +187,32 @@ If you don't want to name your column with the same name than your StaticRecord
   # In the model
   has_static_record :any_column_name, class_name: 'Article'
 
+=== StaticRecord
+
+You can also use 'reference' instead of 'attribute' to have your StaticRecords reference other ones.
+
+You must use type :static_record when declaring your column!
+
+  class Article < StaticRecord::Base
+    table       :articles
+    path        Rails.root.join('app', 'models', 'articles', '**', '*.rb')
+    primary_key :name
+
+    columns     name:     :string,
+                category  :static_record
+  end
+
+  class ArticleOne < Article
+    attribute   :name, 'Article one'
+    reference   :category, Category.find('Category One')
+  end
+
+You can query them like this
+
+  Article.where(category: Category.find('Category One'))
+  Article.joins(Category).where("categories.name = 'Category One'")
+  Article.joins("categories").where("categories.name = 'Category One'")
+
 == Questions?
 
 If you have any question or doubt regarding StaticRecord which you cannot find the solution to in the documentation, you can send me an email. I'll try to answer in less than 24 hours.
@@ -165,4 +225,4 @@ If you find a bug please add an issue on GitHub or fork the project and send a p
 
 - Better documentation
 - Generators
-- Allow StaticRecord to reference other static records and add possibility to query over relations (joins)
+- Improve jointures

data/lib/static_record.rb

@@ -1,8 +1,10 @@
 require 'static_record/engine'
 require 'static_record/exceptions'
 
+require 'static_record/concerns/getters_setters_concern'
 require 'static_record/concerns/query_building_concern'
 require 'static_record/concerns/sqlite_storing_concern'
+require 'static_record/concerns/request_execution_concern'
 
 require 'static_record/models/query_interface/conditioners'
 require 'static_record/models/query_interface/retrievers'

data/lib/static_record/concerns/getters_setters_concern.rb

@@ -0,0 +1,43 @@
+module StaticRecord
+  # Contains StaticRecord::Base getters and setters
+  module GettersSettersConcern
+    extend ActiveSupport::Concern
+
+    module ClassMethods # :nodoc:
+      def primary_key(name)
+        err = StaticRecord::Base::RESERVED_ATTRIBUTES.include?("@@#{name}".to_sym)
+        raise StaticRecord::ReservedAttributeName, "#{name} is a reserved name" if err
+        class_variable_set('@@_primary_key', name)
+      end
+
+      def pkey
+        class_variable_defined?(:@@_primary_key) ? class_variable_get('@@_primary_key') : nil
+      end
+
+      def bound_static_tables
+        return {} unless class_variable_defined?(:@@_bound_static_tables)
+        class_variable_get('@@_bound_static_tables')
+      end
+
+      def bound_static_tables=(value)
+        class_variable_set('@@_bound_static_tables', value)
+      end
+
+      def table(store)
+        class_variable_set('@@_store', store.to_s)
+      end
+
+      def store
+        class_variable_get('@@_store')
+      end
+
+      def path(path)
+        class_variable_set('@@_path_pattern', path)
+      end
+
+      def path_pattern
+        class_variable_get('@@_path_pattern')
+      end
+    end
+  end
+end

data/lib/static_record/concerns/query_building_concern.rb

@@ -5,6 +5,7 @@ module StaticRecord
 
     def build_query
       sql = sql_select_from
+      sql += sql_joins unless @joins_clauses.empty?
       sql += sql_where unless @where_clauses.empty?
       sql += sql_order unless @order_by.empty?
       sql += sql_limit_offset if @sql_limit
@@ -17,6 +18,13 @@ module StaticRecord
       "SELECT #{@columns} FROM #{@table}"
     end
 
+    def sql_joins
+      @joins_clauses.map do |joint|
+        " INNER JOIN #{joint} ON "\
+        "#{@store}.#{get_column_for_static_table(joint)} = #{joint}.klass"
+      end.join
+    end
+
     def sql_where
       " WHERE #{where_clause_builder}"
     end
@@ -70,14 +78,14 @@ module StaticRecord
         if value.is_a?(Array)
           # ex: where(name: ['John', 'Jack'])
           # use IN operator
-          value.map! { |v| v =~ /^\d+$/ ? v : "\"#{v}\"" }
+          value.map! { |v| cast(v) }
           inverse = 'NOT ' if clause[:operator] == :not_eq
           "#{key} #{inverse}IN (#{value.join(',')})"
         else
           # ex: where(name: 'John')
           # use = operator
           inverse = '!' if clause[:operator] == :not_eq
-          "#{key} #{inverse}= '#{value}'"
+          "#{key} #{inverse}= #{cast(value)}"
         end
       end
       parts.join(' AND ')
@@ -89,16 +97,32 @@ module StaticRecord
         # Anon parameters
         # ex: where("name = ? OR name = ?", 'John', 'Jack')
         clause[:parameters].each do |param|
-          final_string.sub!(/\?/, "\"#{param}\"")
+          final_string.sub!(/\?/, cast(param))
         end
       elsif clause[:parameters].is_a?(Hash)
         # Named parameters (placeholder condition)
         # ex: where("name = :one OR name = :two", one: 'John', two: 'Smith')
         clause[:parameters].each do |key, value|
-          final_string.sub!(":#{key}", "\"#{value}\"")
+          final_string.sub!(":#{key}", cast(value))
         end
       end
       final_string
     end
+
+    def cast(value)
+      return escape(value.class.name) if value.class < StaticRecord::Base
+      return value.to_s if value =~ /^[+|-]?\d+\.?\d*$/
+      escape(value)
+    end
+
+    def escape(value)
+      return "'#{value}'" unless value.include?('\'')
+      "\"#{value}\""
+    end
+
+    def get_column_for_static_table(table)
+      klass = @klass.constantize
+      klass.bound_static_tables[table.to_sym]
+    end
   end
 end

data/lib/static_record/concerns/request_execution_concern.rb

@@ -0,0 +1,57 @@
+module StaticRecord
+  module RequestExecutionConcern # :nodoc:
+    extend ActiveSupport::Concern
+
+    private
+
+    def exec_request(expectancy = :result_set)
+      return build_query if @only_sql
+
+      dbname = Rails.root.join('db', 'static_records.sqlite3').to_s
+      result = get_expected_result_from_database(dbname, expectancy)
+      cast_result(expectancy, result)
+    end
+
+    def get_expected_result_from_database(dbname, expectancy)
+      result = nil
+
+      begin
+        db = SQLite3::Database.open(dbname)
+        query = build_query
+        if expectancy == :integer
+          result = db.get_first_value(query)
+        else
+          statement = db.prepare(query)
+          result_set = statement.execute
+          result = result_set.map { |row| row[1].constantize.new }
+        end
+      rescue SQLite3::Exception => e
+        error, msg = handle_error(e, query)
+      ensure
+        statement.close if statement
+        db.close if db
+      end
+      raise error, msg if error
+
+      result
+    end
+
+    def handle_error(error, query)
+      msg = query ? "#{error} in #{query}" : error
+      [error, msg]
+    end
+
+    def cast_result(expectancy, result)
+      if expectancy == :result_set
+        case @result_type
+        when :array
+          result = [] if result.nil?
+        when :record
+          result = result.empty? ? nil : result.first
+        end
+      end
+
+      result
+    end
+  end
+end

data/lib/static_record/concerns/sqlite_storing_concern.rb

@@ -8,7 +8,7 @@ module StaticRecord
       def create_store
         cols = class_variable_get(:@@_columns)
         begin
-          dbname = Rails.root.join('db', "static_#{store}.sqlite3").to_s
+          dbname = Rails.root.join('db', 'static_records.sqlite3').to_s
           SQLite3::Database.new(dbname)
           db = SQLite3::Database.open(dbname)
           db.execute("DROP TABLE IF EXISTS #{store}")
@@ -37,7 +37,7 @@ module StaticRecord
 
       def column_type_to_sql(ctype)
         case ctype.to_s
-        when 'string'
+        when 'string', 'static_record'
           ' TEXT'
         else
           " #{ctype.to_s.upcase}"
@@ -54,7 +54,14 @@ module StaticRecord
         sqlized = [index.to_s, "'#{record}'"]
         # model's attributes
         sqlized += cols.map do |name, ctype|
-          ctype == :integer ? attrs[name].to_s : "'#{attrs[name]}'"
+          case ctype
+          when :integer
+            attrs[name].to_s
+          when :static_record
+            "'#{attrs[name].class.name}'"
+          else
+            "'#{attrs[name]}'"
+          end
         end
 
         db.execute("INSERT INTO #{store} VALUES(#{sqlized.join(', ')})")

data/lib/static_record/models/base.rb

@@ -1,6 +1,7 @@
 module StaticRecord
   # Class that immutable model instances can inherit from
   class Base
+    include StaticRecord::GettersSettersConcern
     include StaticRecord::Querying
     include StaticRecord::SqliteStoringConcern
 
@@ -8,14 +9,16 @@ module StaticRecord
       :@@_columns,
       :@@_primary_key,
       :@@_path_pattern,
-      :@@_store
+      :@@_store,
+      :@@_bound_static_tables
     ].freeze
 
     KNOWN_TYPES = [
       :string,
       :boolean,
       :integer,
-      :float
+      :float,
+      :static_record
     ].freeze
 
     def initialize
@@ -34,30 +37,15 @@ module StaticRecord
       class_variable_set("@@#{name}", value)
     end
 
-    def self.primary_key(name)
-      err = RESERVED_ATTRIBUTES.include?("@@#{name}".to_sym)
-      raise StaticRecord::ReservedAttributeName, "#{name} is a reserved name" if err
-      class_variable_set('@@_primary_key', name)
-    end
-
-    def self.pkey
-      class_variable_defined?(:@@_primary_key) ? class_variable_get('@@_primary_key') : nil
-    end
-
-    def self.table(store)
-      class_variable_set('@@_store', store.to_s)
-    end
-
-    def self.store
-      class_variable_get('@@_store')
-    end
-
-    def self.path(path)
-      class_variable_set('@@_path_pattern', path)
-    end
-
-    def self.path_pattern
-      class_variable_get('@@_path_pattern')
+    def self.reference(name, value)
+      attribute(name, value)
+      unless value.class < StaticRecord::Base
+        err = 'Reference only accepts StaticRecords'
+        raise StaticRecord::ClassError, err
+      end
+      tables = superclass.bound_static_tables
+      tables[value.class.store.to_sym] = name
+      superclass.bound_static_tables = tables
     end
 
     def attributes

data/lib/static_record/models/query_interface/search_modifiers.rb

@@ -5,6 +5,12 @@ module StaticRecord
     module SearchModifiers
       private
 
+      def joins(joint)
+        joint = joint.store unless [String, Symbol].include?(joint.class)
+        @joins_clauses << joint
+        self
+      end
+
       def limit(amount)
         @sql_limit = amount
         self

data/lib/static_record/models/querying.rb

@@ -6,15 +6,16 @@ module StaticRecord
 
     module ClassMethods # :nodoc:
       def method_missing(method_sym, *arguments, &block)
-        if Relation.new(nil, store: store).respond_to?(method_sym, true)
-          Relation.new(nil, store: store, primary_key: pkey).send(method_sym, *arguments, &block)
+        params = relation_params
+        if Relation.new(nil, params).respond_to?(method_sym, true)
+          Relation.new(nil, params).send(method_sym, *arguments, &block)
         else
           super
         end
       end
 
       def respond_to?(method_sym, include_private = false)
-        if Relation.new(nil, store: store).respond_to?(method_sym, true)
+        if Relation.new(nil, relation_params).respond_to?(method_sym, true)
           true
         else
           super
@@ -22,12 +23,22 @@ module StaticRecord
       end
 
       def respond_to_missing?(method_sym, include_private = false)
-        if Relation.new(nil, store: store).respond_to_missing?(method_sym, true)
+        if Relation.new(nil, relation_params).respond_to_missing?(method_sym, true)
           true
         else
           super
         end
       end
+
+      private
+
+      def relation_params
+        {
+          klass: name,
+          store: store,
+          primary_key: pkey
+        }
+      end
     end
   end
 end

data/lib/static_record/models/relation.rb

@@ -4,6 +4,7 @@ module StaticRecord
                 :sql_limit,
                 :sql_offset,
                 :where_clauses,
+                :joins_clauses,
                 :chain,
                 :result_type,
                 :order_by,
@@ -11,16 +12,19 @@ module StaticRecord
 
     include StaticRecord::QueryInterface::Interface
     include StaticRecord::QueryBuildingConcern
+    include StaticRecord::RequestExecutionConcern
 
     def initialize(previous_node, params)
       @store = params[:store]
       @table = params[:store]
+      @klass = params[:klass]
       @primary_key = params[:primary_key]
 
       @columns = '*'
       @sql_limit = nil
       @sql_offset = nil
       @where_clauses = []
+      @joins_clauses = []
       @chain = :and
       @result_type = :array
       @order_by = []
@@ -31,7 +35,12 @@ module StaticRecord
 
     def method_missing(method_sym, *arguments, &block)
       if respond_to?(method_sym, true)
-        Relation.new(self, store: @store, primary_key: @primary_key).send(method_sym, *arguments, &block)
+        params = {
+          klass: @klass,
+          store: @store,
+          primary_key: @primary_key
+        }
+        Relation.new(self, params).send(method_sym, *arguments, &block)
       elsif [].respond_to?(method_sym)
         to_a.send(method_sym)
       else
@@ -58,6 +67,7 @@ module StaticRecord
       @sql_limit = relation.sql_limit
       @sql_offset = relation.sql_offset
       @where_clauses = relation.where_clauses.deep_dup
+      @joins_clauses = relation.joins_clauses.deep_dup
       @chain = relation.chain
       @result_type = relation.result_type
       @order_by = relation.order_by.deep_dup
@@ -74,50 +84,5 @@ module StaticRecord
       @where_clauses << clause
       @chain = :and
     end
-
-    def exec_request(expectancy = :result_set)
-      return build_query if @only_sql
-
-      dbname = Rails.root.join('db', "static_#{@store}.sqlite3").to_s
-      result = get_expected_result_from_database(dbname, expectancy)
-      cast_result(expectancy, result)
-    end
-
-    def get_expected_result_from_database(dbname, expectancy)
-      result = nil
-
-      begin
-        db = SQLite3::Database.open(dbname)
-        if expectancy == :integer
-          result = db.get_first_value(build_query)
-        else
-          statement = db.prepare(build_query)
-          result_set = statement.execute
-          result = result_set.map { |row| row[1].constantize.new }
-        end
-      rescue SQLite3::Exception => e
-        error = e
-      ensure
-        statement.close if statement
-        db.close if db
-      end
-
-      raise error if error
-
-      result
-    end
-
-    def cast_result(expectancy, result)
-      if expectancy == :result_set
-        case @result_type
-        when :array
-          result = [] if result.nil?
-        when :record
-          result = result.empty? ? nil : result.first
-        end
-      end
-
-      result
-    end
   end
 end

data/lib/static_record/version.rb

@@ -1,3 +1,3 @@
 module StaticRecord
-  VERSION = '1.1.0'.freeze
+  VERSION = '1.2.0'.freeze
 end

data/spec/models/relation_spec.rb

@@ -141,7 +141,7 @@ RSpec.describe StaticRecord::Relation, :type => :model do
 
     it 'accepts array of values' do
       expect(Article.where(name: ['Article One', 'Article Two']).to_a.size).to eql(2)
-      expect(Article.where(name: ['Article One', 'Article Two']).to_sql).to eql("SELECT * FROM articles WHERE name IN (\"Article One\",\"Article Two\")")
+      expect(Article.where(name: ['Article One', 'Article Two']).to_sql).to eql("SELECT * FROM articles WHERE name IN ('Article One','Article Two')")
     end
 
     it 'accepts strings' do
@@ -151,17 +151,17 @@ RSpec.describe StaticRecord::Relation, :type => :model do
 
     it 'accepts strings followed by an anonymous parameters' do
       expect(Article.where("name = ?", 'Article Two').first.class).to eql(ArticleTwo)
-      expect(Article.where("name = ?", 'Article Two').to_sql).to eql("SELECT * FROM articles WHERE name = \"Article Two\"")
+      expect(Article.where("name = ?", 'Article Two').to_sql).to eql("SELECT * FROM articles WHERE name = 'Article Two'")
     end
 
     it 'accepts strings followed by several anonymous parameters' do
       expect(Article.where("name = ? AND author = ?", 'Article Two', 'The author').first.class).to eql(ArticleTwo)
-      expect(Article.where("name = ? AND author = ?", 'Article Two', 'The author').to_sql).to eql("SELECT * FROM articles WHERE name = \"Article Two\" AND author = \"The author\"")
+      expect(Article.where("name = ? AND author = ?", 'Article Two', 'The author').to_sql).to eql("SELECT * FROM articles WHERE name = 'Article Two' AND author = 'The author'")
     end
 
     it 'accepts strings followed by a hash of named parameters' do
       expect(Article.where("name = :name AND author = :author", {name: 'Article Two', author: 'The author'}).first.class).to eql(ArticleTwo)
-      expect(Article.where("name = :name AND author = :author", {name: 'Article Two', author: 'The author'}).to_sql).to eql("SELECT * FROM articles WHERE name = \"Article Two\" AND author = \"The author\"")
+      expect(Article.where("name = :name AND author = :author", {name: 'Article Two', author: 'The author'}).to_sql).to eql("SELECT * FROM articles WHERE name = 'Article Two' AND author = 'The author'")
     end
   end
 
@@ -178,7 +178,7 @@ RSpec.describe StaticRecord::Relation, :type => :model do
     it 'is possible to chain where.not and where.not clauses' do
       request = Article.where.not(author: ['The author', 'Me']).where.not(name: 'Article Two')
       expect(request.last.class.name).to eql(ArticleThree.name)
-      expect(request.to_sql).to eql("SELECT * FROM articles WHERE author NOT IN (\"The author\",\"Me\") AND name != 'Article Two'")
+      expect(request.to_sql).to eql("SELECT * FROM articles WHERE author NOT IN ('The author','Me') AND name != 'Article Two'")
     end
   end
 
@@ -207,7 +207,7 @@ RSpec.describe StaticRecord::Relation, :type => :model do
 
     it 'accepts array of values' do
       expect(Article.find(['Article One', 'Article Two']).to_a.size).to eql(2)
-      expect(Article.see_sql_of.find(['Article One', 'Article Two'])).to eql("SELECT * FROM articles WHERE name IN (\"Article One\",\"Article Two\")")
+      expect(Article.see_sql_of.find(['Article One', 'Article Two'])).to eql("SELECT * FROM articles WHERE name IN ('Article One','Article Two')")
     end
 
     context 'one value' do
@@ -249,4 +249,13 @@ RSpec.describe StaticRecord::Relation, :type => :model do
       expect(Article.where(author: 'Inexisting author').or.where(author: 'The author').to_sql).to eql("SELECT * FROM articles WHERE author = 'Inexisting author' OR author = 'The author'")
     end
   end
+
+  context '.joins' do
+    it 'allows to use the SQL JOIN clause' do
+      expect(Article.joins(:categories).where("categories.name = 'Category One'").first.class).to eql(ArticleOne)
+      expected_sql = "SELECT * FROM articles INNER JOIN categories ON articles.category = categories.klass"
+      expect(Article.joins(:categories).to_sql).to eql(expected_sql)
+      expect(Article.joins(Category).to_sql).to eql(expected_sql)
+    end
+  end
 end

data/spec/models/static_record_reference_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+require 'rails_helper'
+
+RSpec.describe StaticRecord::Base, :type => :module do
+  it 'can query over a static record reference' do
+    category = Category.find('Category One')
+    article = Article.where(category: category)
+    expect(article.first.category.class).to eql(category.class)
+  end
+end

data/spec/test_app/app/models/article.rb

@@ -11,6 +11,10 @@ class Article < StaticRecord::Base
     3
   end
 
+  def self.default_category
+    Category.find('Category Two')
+  end
+
   def self.override_cover(cover)
     unless cover.to_s.include?('/')
       folder = Rails.root.join('public', 'articles', 'cover').itself
@@ -23,5 +27,6 @@ class Article < StaticRecord::Base
               author:     :string,
               rank:       :integer,
               important:  :boolean,
-              cover:      :string
+              cover:      :string,
+              category:   :static_record
 end

data/spec/test_app/app/models/articles/article_one.rb

@@ -4,4 +4,6 @@ class ArticleOne < Article
   attribute :rank, 2
   attribute :important, false
   attribute :cover, Rails.root.join('public', 'articles', 'cover', 'article_one.jpg')
+
+  reference :category, Category.find('Category One')
 end

data/spec/test_app/app/models/categories/category_one.rb

@@ -0,0 +1,4 @@
+class CategoryOne < Category
+  attribute :name, 'Category One'
+  attribute :description, 'This is a category'
+end

data/spec/test_app/app/models/categories/category_two.rb

@@ -0,0 +1,4 @@
+class CategoryTwo < Category
+  attribute :name, 'Category Two'
+  attribute :description, 'This is a category'
+end

data/spec/test_app/app/models/category.rb

@@ -0,0 +1,7 @@
+class Category < StaticRecord::Base
+  table     :categories
+  path      Rails.root.join('app', 'models', 'categories', '**', '*.rb')
+  primary_key :name
+  columns   name:         :string,
+            description:  :string
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: static-record
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Hugo Chevalier
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-07 00:00:00.000000000 Z
+date: 2016-01-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -144,7 +144,9 @@ files:
 - app/views/layouts/static_record/application.html.erb
 - config/routes.rb
 - lib/static_record.rb
+- lib/static_record/concerns/getters_setters_concern.rb
 - lib/static_record/concerns/query_building_concern.rb
+- lib/static_record/concerns/request_execution_concern.rb
 - lib/static_record/concerns/sqlite_storing_concern.rb
 - lib/static_record/engine.rb
 - lib/static_record/exceptions.rb
@@ -167,6 +169,7 @@ files:
 - spec/models/default_value_spec.rb
 - spec/models/querying_spec.rb
 - spec/models/relation_spec.rb
+- spec/models/static_record_reference_spec.rb
 - spec/rails_helper.rb
 - spec/spec_helper.rb
 - spec/test_app/app/controllers/application_controller.rb
@@ -179,6 +182,9 @@ files:
 - spec/test_app/app/models/articles/article_two.rb
 - spec/test_app/app/models/badge.rb
 - spec/test_app/app/models/badges/badge_one.rb
+- spec/test_app/app/models/categories/category_one.rb
+- spec/test_app/app/models/categories/category_two.rb
+- spec/test_app/app/models/category.rb
 - spec/test_app/app/models/role.rb
 - spec/test_app/app/models/roles/role_one.rb
 - spec/test_app/app/models/roles/role_two.rb
@@ -234,6 +240,7 @@ test_files:
 - spec/models/default_value_spec.rb
 - spec/models/querying_spec.rb
 - spec/models/relation_spec.rb
+- spec/models/static_record_reference_spec.rb
 - spec/rails_helper.rb
 - spec/spec_helper.rb
 - spec/test_app/app/controllers/application_controller.rb
@@ -246,6 +253,9 @@ test_files:
 - spec/test_app/app/models/articles/article_two.rb
 - spec/test_app/app/models/badge.rb
 - spec/test_app/app/models/badges/badge_one.rb
+- spec/test_app/app/models/categories/category_one.rb
+- spec/test_app/app/models/categories/category_two.rb
+- spec/test_app/app/models/category.rb
 - spec/test_app/app/models/role.rb
 - spec/test_app/app/models/roles/role_one.rb
 - spec/test_app/app/models/roles/role_two.rb