static-record 1.0.0.pre

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a8eb89ed57ec1a0a6fbc6574e1c1614cda528447
+  data.tar.gz: ffffe730a97c3953064f7e2f517d840852ecf48e
+SHA512:
+  metadata.gz: 0d93d7d7ebcc4b347ccad1863e4ce43d3a51688022b7e4b2292820292a3ff0eafa49f1713c1f12058da444517d6c1605ff7d0db57da3401bd630e1bab0efb731
+  data.tar.gz: 40483219ffbe67bd87118e3d9175b5be8c7b681a6f8909b9188f1efc887f5fedc05c6a7594bdde42714fb5140d67b6be56dc099d50cfdb8bd5116330f7901b53

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2016 Hugo Chevalier
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,112 @@
+= StaticRecord
+
+StaticRecord allows you to perform ActiveRecord-like queries over ruby files.
+
+Those files act as immutable database records that only developers can alter.
+
+You can use it when you need several files inheriting a base class.
+
+== Installation
+
+Add this to your Gemfile:
+
+  gem 'static-record'
+
+and run the bundle install command.
+
+== Getting Started
+
+=== Base class
+
+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)
+    table       :articles
+
+    # Declare at which path "article" files can be found
+    path        Rails.root.join('app', 'models', 'articles', '**', '*.rb')
+
+    # Optionnal, declare which column can be used as the primary key (must be unique)
+    # .find will only be availble if a primary key is defined
+    primary_key :name
+
+    # Specify which "article" attributes can be queried over
+    columns     [:name, :author, :rank]
+  end
+
+At each application startup, an SQLite3 database will be created to store this class' children.
+
+=== Child class
+
+Create has many child class as you want.
+
+  class ArticleOne < Article
+    # Define the attributes that will be available for your StaticRecord queries
+    attribute :name, 'Article One'
+    attribute :author, 'The author'
+    attribute :rank, '2'
+
+    # Your class can be used as any other Ruby class
+    def initialize
+      @an_instance_variable
+      super
+    end
+
+    def my_instance_method
+    end
+
+    def self.my_class_method
+    end
+  end
+
+=== Queries
+
+In your code, you can perform queries like this one:
+
+Article.where(name: 'Article Two').or.where.not(author: ['Author 1', 'Author 2']).limit(2).offset(3)
+
+I tried to implement as many SQL functions wrappers that ActiveRecord provides as I could.
+
+There is still a lot of work before everything is available, but I chosed to release the 1.0.0.pre 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')
+* find (requires a primary key has been set)
+* find_by
+* not
+* or
+* all
+* take
+* first
+* last
+* limit
+* offset
+* order
+
+== IDs
+
+Records are being assigned an ID in the SQLite3 database when inserted.
+
+As the database is recreated at each application startup and IDs depend on the insertion order, I advise you to rely on another column if you want to hardcode a specific record somewhere in your app.
+
+== 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.
+
+== Bugs?
+
+If you find a bug please add an issue on GitHub or fork the project and send a pull request.
+
+== Development
+
+As StaticRecord is in active development and a full list of feature is already scheduled, I won't be accepting any feature-oriented pull requests before the 1.0.0 release (hopefully before mi-January).
+
+Here is what will be available soon:
+- Better documentation
+- Typed attributes
+- Foreign keys
+- Joins
+- Generators

data/Rakefile

@@ -0,0 +1,22 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'StaticRecord'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path('../spec/test_app/Rakefile', __FILE__)
+load 'rails/tasks/engine.rake'
+
+load 'rails/tasks/statistics.rake'
+
+Bundler::GemHelper.install_tasks

data/app/assets/javascripts/static_record/application.js

@@ -0,0 +1,13 @@
+// This is a manifest file that'll be compiled into application.js, which will include all the files
+// listed below.
+//
+// Any JavaScript/Coffee file within this directory, lib/assets/javascripts, vendor/assets/javascripts,
+// or any plugin's vendor/assets/javascripts directory can be referenced here using a relative path.
+//
+// It's not advisable to add code directly here, but if you do, it'll appear at the bottom of the
+// compiled file.
+//
+// Read Sprockets README (https://github.com/sstephenson/sprockets#sprockets-directives) for details
+// about supported directives.
+//
+//= require_tree .

data/app/assets/stylesheets/static_record/application.css

@@ -0,0 +1,15 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or any plugin's vendor/assets/stylesheets directory can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the bottom of the
+ * compiled file so the styles you add here take precedence over styles defined in any styles
+ * defined in the other CSS/SCSS files in this directory. It is generally better to create a new
+ * file per style scope.
+ *
+ *= require_tree .
+ *= require_self
+ */

data/app/controllers/static_record/application_controller.rb

@@ -0,0 +1,4 @@
+module StaticRecord
+  class ApplicationController < ActionController::Base
+  end
+end

data/app/helpers/static_record/application_helper.rb

@@ -0,0 +1,4 @@
+module StaticRecord
+  module ApplicationHelper # :nodoc:
+  end
+end

data/app/models/concerns/query_building_concern.rb

@@ -0,0 +1,103 @@
+# Helps building SQL queries
+module QueryBuildingConcern
+  extend ActiveSupport::Concern
+
+  def build_query
+    sql = sql_select_from
+    sql += sql_where unless @where_clauses.empty?
+    sql += sql_order unless @order_by.empty?
+    sql += sql_limit_offset if @sql_limit
+    sql
+  end
+
+  private
+
+  def sql_select_from
+    sql = "SELECT #{@columns} FROM #{@table}"
+  end
+
+  def sql_where
+    " WHERE #{where_clause_builder}"
+  end
+
+  def sql_order
+    ord_sql = ''
+    @order_by.each do |ord|
+      ord_sql += ord_sql.empty? ? ' ORDER BY' : ', '
+      case ord.class.name
+      when Hash.name
+        ord_sql += ord.map { |k, v| " #{@table}.#{k.to_s} #{v.to_s.upcase}" }.join(',')
+      when Array.name
+        ord_sql += ord.map { |sym| " #{@table}.#{sym.to_s} ASC" }.join(',')
+      when Symbol.name
+        ord_sql += " #{@table}.#{ord.to_s} ASC"
+      when String.name
+        ord_sql += " #{ord}"
+      end
+    end
+    ord_sql
+  end
+
+  def sql_limit_offset
+    sql = " LIMIT #{@sql_limit}"
+    sql += " OFFSET #{@sql_offset}" if @sql_offset
+    sql
+  end
+
+  def where_clause_builder
+    params = []
+    @where_clauses.map do |clause|
+      subquery = clause[:q]
+      if subquery.is_a?(Hash)
+        params << where_clause_from_hash(clause, subquery)
+      elsif subquery.is_a?(String)
+        params << where_clause_from_string(clause, subquery)
+      end
+
+      if params.size > 1
+        joint = clause[:chain] == :or ? 'OR' : 'AND'
+        params = [params.join(" #{joint} ")]
+      end
+    end
+
+    params.first
+  end
+
+  def where_clause_from_hash(clause, subquery)
+    parts = subquery.keys.map do |key|
+      value = subquery[key]
+      part = ''
+      if value.is_a?(Array)
+        # ex: where(name: ['John', 'Jack'])
+        # use IN operator
+        value.map! { |v| v =~ /^\d+$/ ? v : "\"#{v}\"" }
+        inverse = 'NOT ' if clause[:operator] == :not_eq
+        part = "#{key.to_s} #{inverse}IN (#{value.join(',')})"
+      else
+        # ex: where(name: 'John')
+        # use = operator
+        inverse = '!' if clause[:operator] == :not_eq
+        part = "#{key.to_s} #{inverse}= '#{value}'"
+      end
+    end
+    parts.join(' AND ')
+  end
+
+  def where_clause_from_string(clause, subquery)
+    final_string = subquery
+    if clause[:parameters].is_a?(Array)
+      # Anon parameters
+      # ex: where("name = ? OR name = ?", 'John', 'Jack')
+      clause[:parameters].each do |param|
+        final_string.sub!(/\?/, "\"#{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}\"")
+      end
+    end
+    final_string
+  end
+end

data/app/models/concerns/sqlite_storing_concern.rb

@@ -0,0 +1,61 @@
+# Reads ruby files whose path matches path pattern and store them
+# as records in an SQLite3 database
+module SqliteStoringConcern
+  extend ActiveSupport::Concern
+
+  module ClassMethods # :nodoc:
+    def create_store
+      columns = class_variable_get(:@@_columns)
+      begin
+        dbname = Rails.root.join('db', "static_#{store}.sqlite3").to_s
+        SQLite3::Database.new(dbname)
+        db = SQLite3::Database.open(dbname)
+        db.execute("DROP TABLE IF EXISTS #{store}")
+        create_table(db, columns)
+        load_records.each_with_index do |record, index|
+          insert_into_database(db, record, index, columns)
+        end
+      rescue SQLite3::Exception => e
+        puts 'Exception occurred', e
+      ensure
+        db.close if db
+      end
+    end
+
+    private
+
+    def create_table(db, columns)
+      cols = columns.map { |c| c.to_s + ' TEXT' }.join(', ')
+      sql = "CREATE TABLE #{store}(id INTEGER PRIMARY KEY, klass TEXT, #{cols})"
+      db.execute(sql)
+    end
+
+    def insert_into_database(db, record, index, columns)
+      attrs = record.constantize.new.attributes
+      sqlized = [index.to_s, "'#{record}'"] # id, klass
+      sqlized += columns.map { |c| "'#{attrs[c]}'" } # model's attributes
+      db.execute("INSERT INTO #{store} VALUES(#{sqlized.join(', ')})")
+    end
+
+    def load_records
+      records = []
+      Dir.glob(path_pattern) do |filepath|
+        klass = get_class_from_file(filepath)
+        if klass
+          require filepath
+          records << klass
+        end
+      end
+      records
+    end
+
+    def get_class_from_file(filepath)
+      klass = nil
+      File.open(filepath) do |file|
+        match = file.grep(/class\s+([a-zA-Z0-9_]+)/)
+        klass = match.first.chomp.gsub(/class\s+/, '').split(' ')[0] if match
+      end
+      klass
+    end
+  end
+end

data/app/models/static_record/base.rb

@@ -0,0 +1,61 @@
+module StaticRecord
+  # Class that immutable model instances can inherit from
+  class Base
+    include StaticRecord::Querying
+    include StaticRecord::SqliteStoringConcern
+
+    RESERVED_ATTRIBUTES = [
+      :@@_columns,
+      :@@_primary_key,
+      :@@_path_pattern,
+      :@@_store
+    ].freeze
+
+    def self.attribute(name, value)
+      err = RESERVED_ATTRIBUTES.include?("@@#{name}".to_sym)
+      raise StaticRecord::ReservedAttributeName, "#{name} is a reserved name" if err
+      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')
+    end
+
+    def attributes
+      attrs = {}
+      klass = self.class
+      klass.class_variables.each do |var|
+        next if RESERVED_ATTRIBUTES.include?(var)
+        attrs[var.to_s.sub(/@@/, '').to_sym] = klass.class_variable_get(var)
+      end
+      attrs
+    end
+
+    def self.columns(cols)
+      class_variable_set('@@_columns', cols)
+      create_store
+    end
+  end
+end

data/app/models/static_record/predicates.rb

@@ -0,0 +1,100 @@
+module StaticRecord
+  # Contains ActiveRecord-like query predicates
+  module Predicates
+    private
+
+    def where(query = nil, *params)
+      params = [params] unless params.is_a?(Array) || params.is_a?(Hash)
+      params = params.first if params.size == 1 && params[0].is_a?(Hash)
+      add_subclause({ q: query }, params) if query
+      self
+    end
+
+    def not(query, *params)
+      params = [params] unless params.is_a?(Array) || params.is_a?(Hash)
+      params = params.first if params.size == 1 && params[0].is_a?(Hash)
+      add_subclause({ q: query, operator: :not_eq }, params)
+      self
+    end
+
+    def or
+      @chain = :or
+      self
+    end
+
+    def all
+      to_a
+    end
+
+    def find(value)
+      raise StaticRecord::NoPrimaryKey, 'No primary key have been set' if @primary_key.nil?
+      @result_type = :record unless value.is_a?(Array)
+      add_subclause(q: { :"#{@primary_key}" => value })
+      @sql_limit = 1 if @result_type == :record
+
+      res = to_a
+      return res if @only_sql
+
+      raise StaticRecord::RecordNotFound, "Couldn't find all #{@store.singularize.capitalize} with '#{@primary_key.to_s}' IN #{value}" if @result_type == :array && res.size != value.size
+      raise StaticRecord::RecordNotFound, "Couldn't find #{@store.singularize.capitalize} with '#{@primary_key.to_s}'=#{value}" if @result_type == :record && res.nil?
+
+      res
+    end
+
+    def find_by(query)
+      add_subclause(q: query)
+      take(1)
+    end
+
+    def take(amount = 1)
+      @sql_limit = amount
+      @result_type = :record if amount == 1
+      to_a
+    end
+
+    def first(amount = 1)
+      @order_by << { :"#{@primary_key}" => :asc } if @order_by.empty?
+      take(amount)
+    end
+
+    def last(amount = 1)
+      @order_by << { :"#{@primary_key}" => :desc } if @order_by.empty?
+      res = take(amount)
+      res.reverse! if res.is_a?(Array)
+      res
+    end
+
+    def limit(amount)
+      @sql_limit = amount
+      self
+    end
+
+    def offset(amount)
+      @sql_offset = amount
+      self
+    end
+
+    def order(ord)
+      @order_by << ord
+      self
+    end
+
+    def count
+      @columns = 'COUNT(*)'
+      exec_request(:integer)
+    end
+
+    def to_sql
+      build_query
+    end
+
+    def see_sql_of
+      @only_sql = true
+      self
+    end
+
+    def to_a
+      exec_request
+    end
+  end
+end