static-record 1.0.0.pre → 1.0.0.pre.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a8eb89ed57ec1a0a6fbc6574e1c1614cda528447
-  data.tar.gz: ffffe730a97c3953064f7e2f517d840852ecf48e
+  metadata.gz: a561fe2ae524c134408db76ff95bad7e8b5f11c9
+  data.tar.gz: c0a00cf2f7342dfd97d5ebe4e18c650ba50abc81
 SHA512:
-  metadata.gz: 0d93d7d7ebcc4b347ccad1863e4ce43d3a51688022b7e4b2292820292a3ff0eafa49f1713c1f12058da444517d6c1605ff7d0db57da3401bd630e1bab0efb731
-  data.tar.gz: 40483219ffbe67bd87118e3d9175b5be8c7b681a6f8909b9188f1efc887f5fedc05c6a7594bdde42714fb5140d67b6be56dc099d50cfdb8bd5116330f7901b53
+  metadata.gz: 5f9aaf4e4bdeb208ea94137af0d1a2f0833792636c05d01aff82ccfb070e61e162e43decf9836bd1bc89e6c1b01b589b6eab058d8a74c2deb1837b506e4048f2
+  data.tar.gz: 9e62c0b5d76b45aec821bc2d588256bd49bf3cece1d322185c9eafb769263234b2a5a90abcdc14ba2f890f00d955d9e340579dc64dca91ff6f15fb067f4343d3

data/README.rdoc

@@ -10,10 +10,13 @@ You can use it when you need several files inheriting a base class.
 
 Add this to your Gemfile:
 
-  gem 'static-record'
+  gem 'static_record', require: 'static_record'
 
 and run the bundle install command.
 
+The 'require' part is important so that Rails autoloads the library correctly.
+
+
 == Getting Started
 
 === Base class

data/lib/static_record.rb

@@ -1,5 +1,13 @@
 require 'static_record/engine'
 require 'static_record/exceptions'
 
+require 'static_record/concerns/query_building_concern'
+require 'static_record/concerns/sqlite_storing_concern'
+
+require 'static_record/models/predicates'
+require 'static_record/models/querying'
+require 'static_record/models/relation'
+require 'static_record/models/base'
+
 module StaticRecord
 end

data/lib/static_record/concerns/query_building_concern.rb

@@ -0,0 +1,105 @@
+module StaticRecord
+  # 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
+end

data/lib/static_record/concerns/sqlite_storing_concern.rb

@@ -0,0 +1,63 @@
+module StaticRecord
+  # 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
+end

data/lib/static_record/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: static-record
 version: !ruby/object:Gem::Version
-  version: 1.0.0.pre
+  version: 1.0.0.pre.1
 platform: ruby
 authors:
 - Hugo Chevalier
@@ -99,17 +99,17 @@ files:
 - app/assets/stylesheets/static_record/application.css
 - app/controllers/static_record/application_controller.rb
 - app/helpers/static_record/application_helper.rb
-- app/models/concerns/query_building_concern.rb
-- app/models/concerns/sqlite_storing_concern.rb
-- app/models/static_record/base.rb
-- app/models/static_record/predicates.rb
-- app/models/static_record/querying.rb
-- app/models/static_record/relation.rb
 - app/views/layouts/static_record/application.html.erb
 - config/routes.rb
 - lib/static_record.rb
+- lib/static_record/concerns/query_building_concern.rb
+- lib/static_record/concerns/sqlite_storing_concern.rb
 - lib/static_record/engine.rb
 - lib/static_record/exceptions.rb
+- lib/static_record/models/base.rb
+- lib/static_record/models/predicates.rb
+- lib/static_record/models/querying.rb
+- lib/static_record/models/relation.rb
 - lib/static_record/version.rb
 - lib/tasks/static_record_tasks.rake
 - spec/models/static_record/base_spec.rb

data/app/models/concerns/query_building_concern.rb

@@ -1,103 +0,0 @@
-# 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

@@ -1,61 +0,0 @@
-# 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