RubyGems - static-record - Versions diffs - 1.0.0.pre - Mend

static-record 1.0.0.pre

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (52) hide show

checksums.yaml +7 -0
data/MIT-LICENSE +20 -0
data/README.rdoc +112 -0
data/Rakefile +22 -0
data/app/assets/javascripts/static_record/application.js +13 -0
data/app/assets/stylesheets/static_record/application.css +15 -0
data/app/controllers/static_record/application_controller.rb +4 -0
data/app/helpers/static_record/application_helper.rb +4 -0
data/app/models/concerns/query_building_concern.rb +103 -0
data/app/models/concerns/sqlite_storing_concern.rb +61 -0
data/app/models/static_record/base.rb +61 -0
data/app/models/static_record/predicates.rb +100 -0
data/app/models/static_record/querying.rb +25 -0
data/app/models/static_record/relation.rb +110 -0
data/app/views/layouts/static_record/application.html.erb +14 -0
data/config/routes.rb +2 -0
data/lib/static_record.rb +5 -0
data/lib/static_record/engine.rb +5 -0
data/lib/static_record/exceptions.rb +5 -0
data/lib/static_record/version.rb +3 -0
data/lib/tasks/static_record_tasks.rake +4 -0
data/spec/models/static_record/base_spec.rb +10 -0
data/spec/models/static_record/querying_spec.rb +8 -0
data/spec/models/static_record/relation_spec.rb +242 -0
data/spec/rails_helper.rb +15 -0
data/spec/spec_helper.rb +18 -0
data/spec/test_app/app/controllers/application_controller.rb +5 -0
data/spec/test_app/app/helpers/application_helper.rb +2 -0
data/spec/test_app/app/models/article.rb +6 -0
data/spec/test_app/app/models/articles/article_four.rb +5 -0
data/spec/test_app/app/models/articles/article_one.rb +5 -0
data/spec/test_app/app/models/articles/article_three.rb +5 -0
data/spec/test_app/app/models/articles/article_two.rb +5 -0
data/spec/test_app/app/models/role.rb +5 -0
data/spec/test_app/app/models/roles/role_one.rb +4 -0
data/spec/test_app/config/application.rb +32 -0
data/spec/test_app/config/boot.rb +5 -0
data/spec/test_app/config/environment.rb +5 -0
data/spec/test_app/config/environments/development.rb +41 -0
data/spec/test_app/config/environments/production.rb +79 -0
data/spec/test_app/config/environments/test.rb +42 -0
data/spec/test_app/config/initializers/assets.rb +11 -0
data/spec/test_app/config/initializers/backtrace_silencers.rb +7 -0
data/spec/test_app/config/initializers/cookies_serializer.rb +3 -0
data/spec/test_app/config/initializers/filter_parameter_logging.rb +4 -0
data/spec/test_app/config/initializers/inflections.rb +16 -0
data/spec/test_app/config/initializers/mime_types.rb +4 -0
data/spec/test_app/config/initializers/session_store.rb +3 -0
data/spec/test_app/config/initializers/wrap_parameters.rb +14 -0
data/spec/test_app/config/routes.rb +4 -0
data/spec/test_app/db/schema.rb +16 -0
metadata +199 -0

data/app/models/static_record/querying.rb ADDED

@@ -0,0 +1,25 @@
+module StaticRecord
+  module Querying # :nodoc:
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+    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)
+        else
+          super
+        end
+      end
+      def respond_to?(method_sym, include_private = false)
+        if Relation.new(nil, store: store).respond_to?(method_sym, true)
+          true
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/app/models/static_record/relation.rb ADDED

@@ -0,0 +1,110 @@
+module StaticRecord
+  class Relation # :nodoc:
+    attr_reader :columns,
+                :sql_limit,
+                :sql_offset,
+                :where_clauses,
+                :chain,
+                :result_type,
+                :order_by,
+                :only_sql
+    include Predicates
+    include StaticRecord::QueryBuildingConcern
+    def initialize(previous_node, params)
+      @store = params[:store]
+      @table = params[:store]
+      @primary_key = params[:primary_key]
+      @columns = '*'
+      @sql_limit = nil
+      @sql_offset = nil
+      @where_clauses = []
+      @chain = :and
+      @result_type = :array
+      @order_by = []
+      @only_sql = false
+      chained_from(previous_node) if previous_node
+    end
+    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)
+      elsif [].respond_to?(method_sym)
+        to_a.send(method_sym)
+      else
+        super
+      end
+    end
+    def respond_to?(method_sym, include_private = false)
+      if !include_private && [].respond_to?(method_sym, include_private)
+        true
+      else
+        super
+      end
+    end
+    private
+    def chained_from(relation)
+      @columns = relation.columns
+      @sql_limit = relation.sql_limit
+      @sql_offset = relation.sql_offset
+      @where_clauses = relation.where_clauses.deep_dup
+      @chain = relation.chain
+      @result_type = relation.result_type
+      @order_by = relation.order_by.deep_dup
+      @only_sql = relation.only_sql
+    end
+    def add_subclause(clause, params = nil)
+      params ||= {}
+      clause[:chain] = @chain unless clause[:chain].present?
+      clause[:operator] = :eq unless clause[:operator].present?
+      clause[:parameters] = params
+      @where_clauses << clause
+      @chain = :and
+    end
+    def exec_request(expectancy = :result_set)
+      return build_query if @only_sql
+      error = nil
+      result = nil
+      begin
+        dbname = Rails.root.join('db', "static_#{@store}.sqlite3").to_s
+        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
+      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/app/views/layouts/static_record/application.html.erb ADDED

@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>StaticRecord</title>
+  <%= stylesheet_link_tag    "static_record/application", media: "all" %>
+  <%= javascript_include_tag "static_record/application" %>
+  <%= csrf_meta_tags %>
+</head>
+<body>
+<%= yield %>
+</body>
+</html>

data/config/routes.rb ADDED

	@@ -0,0 +1,2 @@
1	+ StaticRecord::Engine.routes.draw do
2	+ end

data/lib/static_record.rb ADDED

@@ -0,0 +1,5 @@
+require 'static_record/engine'
+require 'static_record/exceptions'
+module StaticRecord
+end

data/lib/static_record/engine.rb ADDED

@@ -0,0 +1,5 @@
+module StaticRecord
+  class Engine < ::Rails::Engine # :nodoc:
+    isolate_namespace StaticRecord
+  end
+end

data/lib/static_record/exceptions.rb ADDED

@@ -0,0 +1,5 @@
+module StaticRecord
+  class RecordNotFound < RuntimeError; end
+  class ReservedAttributeName < RuntimeError; end
+  class NoPrimaryKey < RuntimeError; end
+end

data/lib/static_record/version.rb ADDED

@@ -0,0 +1,3 @@
+module StaticRecord
+  VERSION = '1.0.0.pre'.freeze
+end

data/lib/tasks/static_record_tasks.rake ADDED

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :static_record do
+#   # Task goes here
+# end

data/spec/models/static_record/base_spec.rb ADDED

@@ -0,0 +1,10 @@
+require 'spec_helper'
+require 'rails_helper'
+RSpec.describe StaticRecord::Base, :type => :model do
+  it 'allows to store primary key' do
+    Article.primary_key :author
+    expect(Article.pkey).to eql(:author)
+    Article.primary_key :name # restoring primary key for other tests
+  end
+end

data/spec/models/static_record/querying_spec.rb ADDED

@@ -0,0 +1,8 @@
+require 'spec_helper'
+require 'rails_helper'
+RSpec.describe StaticRecord::Querying, :type => :model do
+  it 'delegates requests to StaticRecord::Relation' do
+    expect(Article.where(author: 'The author')).to be_a(StaticRecord::Relation)
+  end
+end

data/spec/models/static_record/relation_spec.rb ADDED

@@ -0,0 +1,242 @@
+require 'spec_helper'
+require 'rails_helper'
+RSpec.describe StaticRecord::Relation, :type => :model do
+  it 'returns a StaticRecord::Relation while used method allows chaining' do
+    expect(Article.where(author: 'The author')).to be_a(StaticRecord::Relation)
+    expect(Article.find_by(author: 'The author')).not_to be_a(StaticRecord::Relation)
+  end
+  context '.all' do
+    it 'returns all results' do
+      expect(Article.all.count).to eql(4)
+      expect(Article.see_sql_of.all).to eql("SELECT * FROM articles")
+    end
+  end
+  context '.order' do
+    context 'with a symbol' do
+      it 'returns results ordered' do
+        expected = [ArticleFour, ArticleOne, ArticleThree, ArticleTwo]
+        expect(Article.order(:name).all.map(&:class)).to eql(expected)
+        expect(Article.order(:name).to_sql).to eql("SELECT * FROM articles ORDER BY articles.name ASC")
+      end
+    end
+    context 'with a string' do
+      it 'returns results ordered' do
+        expected = [ArticleTwo, ArticleThree, ArticleOne, ArticleFour]
+        expect(Article.order("name DESC").all.map(&:class)).to eql(expected)
+        expect(Article.order("name DESC").to_sql).to eql("SELECT * FROM articles ORDER BY name DESC")
+      end
+    end
+    context 'with a hash' do
+      it 'returns results ordered with one key' do
+        expected = [ArticleFour, ArticleOne, ArticleThree, ArticleTwo]
+        expect(Article.order(name: :asc).all.map(&:class)).to eql(expected)
+        expect(Article.order(name: :asc).to_sql).to eql("SELECT * FROM articles ORDER BY articles.name ASC")
+      end
+      it 'returns results ordered with serveral keys' do
+        expected = [ArticleThree, ArticleOne, ArticleTwo, ArticleFour]
+        expect(Article.order(rank: :asc, name: :desc).all.map(&:class)).to eql(expected)
+        expect(Article.order(rank: :asc, name: :desc).to_sql).to eql("SELECT * FROM articles ORDER BY articles.rank ASC, articles.name DESC")
+      end
+    end
+    context 'with an array' do
+      it 'returns results ordered with one key' do
+        expected = [ArticleFour, ArticleOne, ArticleThree, ArticleTwo]
+        expect(Article.order([:name]).all.map(&:class)).to eql(expected)
+        expect(Article.order([:name]).to_sql).to eql("SELECT * FROM articles ORDER BY articles.name ASC")
+      end
+      it 'returns results ordered with several keys' do
+        expected = [ArticleThree, ArticleOne, ArticleFour, ArticleTwo]
+        expect(Article.order([:rank, :name]).all.map(&:class)).to eql(expected)
+        expect(Article.order([:rank, :name]).to_sql).to eql("SELECT * FROM articles ORDER BY articles.rank ASC, articles.name ASC")
+      end
+    end
+  end
+  context '.first' do
+    context 'without parameter' do
+      it 'returns first record ordered by primary key' do
+        expect(Article.first.class).to eql(ArticleFour)
+        expect(Article.see_sql_of.first).to eql("SELECT * FROM articles ORDER BY articles.name ASC LIMIT 1")
+      end
+    end
+    context 'with a parameter' do
+      it 'orders records by primary key and returns up to specified number of records from the beginning' do
+        expect(Article.first(2).map(&:class)).to eql([ArticleFour, ArticleOne])
+        expect(Article.see_sql_of.first(2)).to eql("SELECT * FROM articles ORDER BY articles.name ASC LIMIT 2")
+      end
+    end
+  end
+  #TODO: implement .first!
+  context '.last' do
+    context 'without parameter' do
+      it 'returns last record ordered by primary key' do
+        expect(Article.last.class).to eql(ArticleTwo)
+        expect(Article.see_sql_of.last).to eql("SELECT * FROM articles ORDER BY articles.name DESC LIMIT 1")
+      end
+    end
+    context 'with a parameter' do
+      it 'orders records by primary key and returns up to specified number of records from the end' do
+        expect(Article.last(2).map(&:class)).to eql([ArticleThree, ArticleTwo])
+        expect(Article.see_sql_of.last(2)).to eql("SELECT * FROM articles ORDER BY articles.name DESC LIMIT 2")
+      end
+    end
+  end
+  context '.limit' do
+    it 'returns up to specified number of records' do
+      expect(Article.limit(2).all.map(&:class)).to eql([ArticleFour, ArticleOne])
+      expect(Article.limit(2).to_sql).to eql("SELECT * FROM articles LIMIT 2")
+    end
+  end
+  context '.limit.offset' do
+    it 'returns up to specified number of records with specified offset' do
+      expect(Article.limit(2).offset(1).all.map(&:class)).to eql([ArticleOne, ArticleThree])
+      expect(Article.limit(2).offset(1).to_sql).to eql("SELECT * FROM articles LIMIT 2 OFFSET 1")
+    end
+  end
+  #TODO: implement .last!
+  context '.count' do
+    it 'returns results count using SQL SELECT COUNT()' do
+      expect(Article.where(author: 'The author').count).to eql(2)
+      expect(Article.where(author: 'The author').see_sql_of.count).to eql("SELECT COUNT(*) FROM articles WHERE author = 'The author'")
+    end
+  end
+  context '.where' do
+    it 'returns an empty array when no result' do
+      expect(Article.where(author: 'Inexisting author')).to be_empty
+    end
+    it 'is possible to chain where clauses' do
+      request = Article.where(author: 'The author').where(name: 'Article One')
+      expect(request.last.class.name).to eql(ArticleOne.name)
+      expect(request.to_sql).to eql("SELECT * FROM articles WHERE author = 'The author' AND name = 'Article One'")
+    end
+    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\")")
+    end
+    it 'accepts strings' 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'")
+    end
+    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\"")
+    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\"")
+    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\"")
+    end
+  end
+  context '.where.not' do
+    it 'uses SQL != operator' do
+    end
+    it 'is possible to chain where and where.not clauses' do
+      request = Article.where(author: 'The author').where.not(name: 'Article Two')
+      expect(request.last.class.name).to eql(ArticleOne.name)
+      expect(request.to_sql).to eql("SELECT * FROM articles WHERE author = 'The author' AND name != 'Article Two'")
+    end
+    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'")
+    end
+  end
+  context '.find_by' do
+    it 'limits result to 1 record' do
+      expect(Article.find_by(author: 'The author').class.name).to eql(ArticleOne.name)
+      expect(Article.see_sql_of.find_by(author: 'The author')).to eql("SELECT * FROM articles WHERE author = 'The author' LIMIT 1")
+    end
+    it 'returns nil when no result' do
+      expect(Article.find_by(author: 'Inexisting author')).to be_nil
+    end
+  end
+  #TODO: implement .find_by!
+  context '.find' do
+    it 'raises an error when no primary key has been set' do
+      expect{ Role.find('Role One') }.to raise_error(StaticRecord::NoPrimaryKey)
+    end
+    it 'searches by primary key' do
+      expect(Article.find('Article Two').class.name).to eql(ArticleTwo.name)
+      expect(Article.see_sql_of.find('Article Two')).to eql("SELECT * FROM articles WHERE name = 'Article Two' LIMIT 1")
+    end
+    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\")")
+    end
+    context 'one value' do
+      it 'raises an error when no result' do
+        expect{ Article.find('Inexisting Article') }.to raise_error(StaticRecord::RecordNotFound)
+      end
+    end
+    context 'several values' do
+      it 'raises an error when not all results are found' do
+        expect{ Article.find(['Article One', 'Inexisting Article']) }.to raise_error(StaticRecord::RecordNotFound)
+      end
+    end
+  end
+  #TODO: implement find_each and find_in_batches
+  context '.take' do
+    context 'without parameter' do
+      it 'returns a single record' do
+        expect(Article.take.class).to be < Article
+        expect(Article.see_sql_of.take).to eql("SELECT * FROM articles LIMIT 1")
+      end
+    end
+    context 'with a parameter' do
+      it 'returns up to the specified number of records' do
+        expect(Article.take(2).size).to eql(2)
+        expect(Article.see_sql_of.take(2)).to eql("SELECT * FROM articles LIMIT 2")
+      end
+    end
+  end
+  #TODO: implement .take!
+  context '.or' do
+    it 'allows to use the SQL OR' do
+      expect(Article.where(author: 'Inexisting author').or.where(author: 'The author').size).to eql(2)
+      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
+end