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

static-record 1.0.0.pre

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