rollerskates 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7ae0700f032e105dbc7cbb89d83cc9b19b964a4b
-  data.tar.gz: 1a72d44264c07dca64df5fcb2f37f0bec46f1281
+  metadata.gz: 290bc3701e17c3951d3f2c07064d3323e54508bc
+  data.tar.gz: 3b89ebea759281b73d0aa902325251a15e060440
 SHA512:
-  metadata.gz: f6f092c09b853b9fa3c7337454746f0e30e41b258a47e90653b3f9c069e2dcd84e4f256b07a45968a5af2e96e8600fd448c31c0a2fe018c66d86423ac9c696bc
-  data.tar.gz: aa7aa9be0a13306ded382ed5cd740f9ae55b3091b54214c22a5a1169ae6261910e5e025f4c3c70fa4b82aac32fd472a2d86424e743fd532de8842255358c6668
+  metadata.gz: 811a08e65001fec6c57d71bec7aa857d57cc910b25e1c5288e4dd9a3f4f5af68d0693415165dae414ec8d31687469fd093fef98fe1044fa0b120d3e2ff0d9f6a
+  data.tar.gz: 4c3f6fe6477224e872393a1a5875952df243e41c37273082f6a09fd28ac5d3388ec17813f8ddc848685efaf20da33269b2463869f44e70c2bdfd35e9fd6c61e7

data/.rubocop.yml

@@ -60,7 +60,6 @@ Style/PredicateName:
   Enabled: true
   NamePrefix:
   - is_
-  - has_
   - have_
   NamePrefixBlacklist:
   - is_

data/README.md

@@ -36,7 +36,7 @@ app_name
 |    └─── routes.rb
 |    └───application.rb
 └───db
-|    └───development.sqlite3
+|    └───app.db
 └───config.ru
 ```
 
@@ -57,10 +57,13 @@ Allow your application class to inherit form `Rollerskates::Application` class
 Set up your routes this way:
 
 ```ruby
-require "/config/application.rb"
+APP_ROOT = __dir__
+require_relative "./config/application.rb"
 TodoApplication = Todolist::Application.new
+use Rack::Reloader, 0
 use Rack::MethodOverride
-require "/config/routes.rb"
+require_relative "./config/routes.rb"
+use Rack::Static, urls: ["/css", "/js", "/fonts"], root: "/app/assets"
 run TodoApplication
 ```
 
@@ -104,10 +107,30 @@ class Item < Rollerskates::BaseRecord
   property :status, type: :boolean, nullable: false
 
   create_table
+  belongs_to :user
+  has_many :product
+  
+  def self.recent
+    order("id DESC").limit(5)
+  end
 end
 ```
 Rolletskates automatically adds the `id, created_at and updated_at` fields and thus need not to be specified in the model. Other properties, however should be specified as above.
 
+You can make use of associations with the rollerskates framework. Also, you can chain methods to a degree. Rollerskates ORM can accommodate chaining such as:
+> `select(:prop1, :prop2, :prop3)`
+> 
+> `where(prop2: "Value")`
+> 
+> `order("prop DESC")`
+> 
+> `limit(5)`
+
+And combinations such as:
+> `select(:id, :name).where(status: "active").limit(5)`
+
+NB: Unlike Rails, `Rollerskates` uses sigular expression for both `has_many` and `belongs_to`
+
 ### Views
 
 ```
@@ -116,9 +139,13 @@ Rolletskates automatically adds the `id, created_at and updated_at` fields and t
 |   └───items
 |       |____ new.erb
 |       |____ show.erb
+|───────layouts
+|       |____ application.erb
 
 ```
-Files in the view folder should be organized according to the controller and action name.
+Files in the view folder should be organized according to the controller and action name. Instance variables declared in the respective controller action are available to your view.
+
+The views make use of a layouts. You can abstract common elements in all your views to the `views/layouts/application.erb` file.
 ## Testing
 
 The tests could be run automatically by using

data/lib/rollerskates/base_model.rb

@@ -1,116 +1,63 @@
-require "rollerskates/helpers/model_helper"
+require "rollerskates/orm/helpers/database_table_helper"
+require "rollerskates/orm/associable"
+require "rollerskates/orm/query_builder"
 
 module Rollerskates
-  class BaseModel < Rollerskates::ModelHelper
+  class BaseModel
+    extend Rollerskates::Associable
+    extend Rollerskates::DatabaseTableHelper
+
     def initialize(values = {})
       hash_to_properties(values) unless values.empty?
     end
 
-    def hash_to_properties(hash)
-      hash.each do |column, value|
-        instance_variable_set("@#{column}", value)
-      end
-    end
-
-    def update(hash)
-      hash_to_properties(hash)
-      @updated_at = Time.now.to_s
-    end
-
     def save
-      create_columns_placeholders_values
-      if id
-        database.execute(update_query, values_for_update)
-      else
-        add_created_at_and_updated_at
-        database.execute "INSERT INTO #{table_name} (#{@columns.join(', ')})\
-          VALUES (#{@placeholders.join(', ')})", @values
-      end
+      self.class.query.build(to_hash).save
     end
 
-    def placeholders_for_update
-      placeholders = @columns.map { |col| col + " = ?" }
-      placeholders.join(", ")
+    def self.find(value)
+      query.where({ id: value }, true)
     end
 
-    def values_for_update
-      @values << id
-    end
-
-    def create_columns_placeholders_values
-      @model = self
-      @columns = []
-      @placeholders = []
-      @values = []
-
-      all_columns.each do |column|
-        value = @model.send(column)
-        next unless value
-        @columns << column.to_s
-        @placeholders << "?"
-        @values << value
-      end
+    def self.find_by(find_conditions)
+      query.where(find_conditions, true)
     end
 
-    def add_created_at_and_updated_at
-      @columns << %w(created_at updated_at)
-      @placeholders << ["?", "?"]
-      @values << [Time.now.to_s, Time.now.to_s]
+    def self.last(number = nil)
+      query.order("id DESC").first(number)
     end
 
-    def self.create(values)
-      new(values).save
+    def self.create(create_parameters)
+      query.build(create_parameters).save
     end
 
     def self.all
-      data = database.execute "SELECT #{all_columns.join(', ')}\
-        FROM #{table_name}"
-      data.map do |row|
-        row_to_object(row)
-      end
-    end
-
-    def self.count
-      data = database.execute "SELECT COUNT(*) FROM #{table_name}"
-      data.flatten.first
+      query
     end
 
-    def self.first
-      data = database.execute "SELECT #{all_columns.join(', ')} \
-        FROM #{table_name} ORDER BY id ASC LIMIT 1"
-      row_to_object(data.flatten)
+    def self.query
+      Rollerskates::QueryBuilder.new self
     end
 
-    def self.last
-      data = database.execute "SELECT #{all_columns.join(', ')} \
-        FROM #{table_name} ORDER BY id DESC LIMIT 1"
-      row_to_object(data.flatten)
+    def self.method_missing(method, *args, &block)
+      query.send(method, *args, &block)
     end
 
-    def self.find(id)
-      data = database.execute "SELECT #{all_columns.join(', ')}\
-        FROM #{table_name} WHERE id = ?", id
-      row_to_object data.flatten
-    end
-
-    def destroy
-      database.execute "DELETE FROM #{table_name} WHERE id = ?", id
-    end
+    private
 
-    def self.destroy(id)
-      database.execute "DELETE FROM #{table_name} WHERE id = ?", id
-    end
-
-    def self.destroy_all
-      database.execute "DELETE FROM #{table_name}"
+    def hash_to_properties(hash)
+      hash.each do |column, value|
+        instance_variable_set("@#{column}", value)
+      end
     end
 
-    def self.row_to_object(row)
-      model = model_name.new
-      all_columns.each_with_index do |attribute, index|
-        model.send("#{attribute}=", row[index])
+    def to_hash
+      hashed_object = {}
+      instance_variables.each do |property|
+        hashed_object[property[1..-1].to_sym] =
+          instance_variable_get(property.to_s)
       end
-      model
+      hashed_object
     end
   end
 end

data/lib/rollerskates/orm/associable.rb

@@ -0,0 +1,20 @@
+module Rollerskates
+  module Associable
+    def belongs_to(table)
+      parent_model = table.to_s.camelize.constantize
+      define_method(table) do
+        parent_model.find_by(id: send("#{table}_id"))
+      end
+    end
+
+    def has_many(table)
+      child_model = table.to_s.camelize.constantize
+      child_table = table.to_s.pluralize
+      parent_model = model_name.to_s.downcase
+      define_method(child_table) do
+        column = "#{parent_model}_id"
+        child_model.where(column => id)
+      end
+    end
+  end
+end

data/lib/rollerskates/orm/helpers/database_table_helper.rb

@@ -0,0 +1,76 @@
+require "sqlite3"
+
+module Rollerskates
+  module DatabaseTableHelper
+    def table_name
+      to_s.downcase.pluralize
+    end
+
+    def database
+      @db ||= SQLite3::Database.new File.join("db", "app.db")
+    end
+
+    def model_name
+      to_s.downcase
+    end
+
+    def all_columns
+      columns = database.prepare "SELECT * FROM #{table_name}"
+      columns.columns.map(&:to_sym)
+    end
+
+    private
+
+    def add_property(property)
+      @properties ||= [
+        "id integer PRIMARY KEY AUTOINCREMENT",
+        "created_at datetime NOT NULL",
+        "updated_at datetime NOT NULL"
+      ]
+      @properties << property
+    end
+
+    def property(field, options)
+      add_property "#{field} #{parse_constraints(options)}"
+    end
+
+    def create_table
+      query = "CREATE TABLE IF NOT EXISTS #{table_name}\
+              (#{@properties.join(', ')})"
+      database.execute(query)
+
+      all_columns.each { |var| attr_accessor var }
+    end
+
+    def parse_constraints(constraints)
+      attributes = ""
+      constraints.each do |attr, value|
+        attributes += send(attr.to_s, value)
+      end
+
+      attributes
+    end
+
+    def type(value)
+      "#{value.to_s.upcase} "
+    end
+
+    def primary_key(value)
+      return "PRIMARY KEY " if value
+      " "
+    end
+
+    def nullable(value)
+      return "NOT NULL " if value
+      "NULL "
+    end
+
+    def default(value)
+      "DEFAULT `#{value}` "
+    end
+
+    def auto_increment(value)
+      "AUTOINCREMENT " if value
+    end
+  end
+end

data/lib/rollerskates/orm/helpers/query_helper.rb

@@ -0,0 +1,107 @@
+module Rollerskates
+  module QueryHelper
+    private
+
+    def table_name
+      @model.table_name
+    end
+
+    def database
+      @model.database
+    end
+
+    def query_statement
+      sql = "#{select_phrase} #{from_phrase}"
+      sql  << where_phrase unless @columns.empty?
+      sql  << order_phrase if @order
+      sql  << limit_phrase if @limit
+      sql  << offset_phrase if @offset
+
+      sql
+    end
+
+    def create_columns
+      @create_parameters[:created_at] = Time.now.to_s
+      @create_parameters[:updated_at] = Time.now.to_s
+      @create_parameters.keys.map { |column| "'#{column}'" }.join(", ")
+    end
+
+    def create_values
+      @create_parameters.values.map { |value| "'#{value}'" }.join(", ")
+    end
+
+    def update_values
+      @update_parameters[:updated_at] = Time.now.to_s
+      @update_parameters.map { |key, value| "#{key}" << " = '#{value}'" }
+    end
+
+    def select_phrase
+      if @count
+        "SELECT COUNT (*)"
+      elsif @select
+        "SELECT #{@select.flatten.join(', ')} "
+      else
+        "SELECT * "
+      end
+    end
+
+    def from_phrase
+      "FROM #{table_name}"
+    end
+
+    def where_phrase
+      string = []
+      @columns.uniq.each do |col|
+        string << col.map { |key, value| "#{key}" << " = '#{value}'" }
+      end
+      " WHERE #{string.join(' AND ')}" unless @columns.empty?
+    end
+
+    def order_phrase
+      " ORDER BY #{@order}" if @order
+    end
+
+    def limit_phrase
+      " LIMIT #{@limit}" if @limit
+    end
+
+    def offset_phrase
+      " OFFSET #{@offset}" if @offset
+    end
+
+    def execute
+      sql = @query ? @query : query_statement
+      @result = database.execute sql
+    end
+
+    def data
+      execute unless @result
+      @data ||= if @type == :collection
+                  @result.map { |row| row_to_object(row) }
+                elsif @type == :object
+                  row_to_object(@result.flatten)
+                end
+    end
+
+    def method_missing(method, *_args)
+      if block_given?
+        data.each { |object| yield object }
+        return true
+      end
+      data.send(method)
+    end
+
+    def columns
+      all_columns = database.prepare query_statement
+      all_columns.columns.map(&:to_sym)
+    end
+
+    def row_to_object(row)
+      model_object = @model.new
+      columns.each_with_index do |attribute, index|
+        model_object.send("#{attribute}=", row[index])
+      end
+      model_object
+    end
+  end
+end

data/lib/rollerskates/orm/query_builder.rb

@@ -0,0 +1,87 @@
+require "rollerskates/orm/helpers/query_helper"
+
+module Rollerskates
+  class QueryBuilder
+    include Rollerskates::QueryHelper
+
+    def initialize(model)
+      @model = model
+      @columns = []
+      @type = :collection
+    end
+
+    def select(*select_conditions)
+      @select = select_conditions
+      self
+    end
+
+    def where(where_conditions, object = nil)
+      if object
+        @type = :object
+        limit(1)
+      end
+
+      @columns << where_conditions
+      self
+    end
+
+    def first(number = nil)
+      @type = :object unless number
+      number ? limit(number) : limit(1)
+    end
+
+    def limit(limit_condition = nil)
+      @limit = limit_condition if limit_condition
+      self
+    end
+
+    def offset(offset_condition)
+      @offset = offset_condition if offset_condition
+      self
+    end
+
+    def order(order_conditions)
+      @order = order_conditions.to_s
+      self
+    end
+
+    def count
+      @count = true
+      execute
+      @result.flatten[0].to_i
+    end
+
+    def update(update_parameters)
+      @update_parameters = update_parameters
+      @query = "UPDATE #{table_name} SET \
+        #{update_values.join(', ')} WHERE id = #{id}"
+      self
+    end
+
+    def build(create_parameters)
+      @create_parameters = create_parameters
+      @query = "INSERT INTO #{table_name} (#{create_columns})\
+        VALUES (#{create_values})"
+      self
+    end
+
+    def destroy(item_id = nil)
+      index = item_id ? item_id : id
+      @query = "DELETE FROM #{table_name} WHERE id = #{index}"
+      execute
+      self
+    end
+
+    def destroy_all
+      @query = "DELETE FROM #{table_name}"
+      execute
+      self
+    end
+
+    def save
+      @type = :object
+      execute
+      data
+    end
+  end
+end

data/lib/rollerskates/version.rb

@@ -1,3 +1,3 @@
 module Rollerskates
-  VERSION = "0.1.0".freeze
+  VERSION = "0.1.1".freeze
 end

data/rollerskates.gemspec

@@ -30,10 +30,12 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", "~> 1.9"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.0"
-  spec.add_development_dependency "coveralls"
-  spec.add_development_dependency "capybara"
+  spec.add_development_dependency "coveralls", "~> 0"
+  spec.add_development_dependency "capybara", "~> 2.6"
 
   spec.add_runtime_dependency "rack", "~> 1.0"
-  spec.add_runtime_dependency "tilt"
-  spec.add_runtime_dependency "sqlite3"
+  spec.add_runtime_dependency "tilt", "~> 0"
+  spec.add_runtime_dependency "pry", "~> 0"
+  spec.add_runtime_dependency "sqlite3", "~> 1.3.11"
+
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rollerskates
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Femi Senjobi
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-06-17 00:00:00.000000000 Z
+date: 2016-06-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -56,30 +56,30 @@ dependencies:
   name: coveralls
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: capybara
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.6'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.6'
 - !ruby/object:Gem::Dependency
   name: rack
   requirement: !ruby/object:Gem::Requirement
@@ -98,30 +98,44 @@ dependencies:
   name: tilt
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: sqlite3
+  name: pry
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.3.11
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.3.11
 description: This is a ruby MVC framework to speed up development time.
 email:
 - femi.senjobi@andela.com
@@ -148,7 +162,10 @@ files:
 - lib/rollerskates/base_controller.rb
 - lib/rollerskates/base_model.rb
 - lib/rollerskates/dependencies.rb
-- lib/rollerskates/helpers/model_helper.rb
+- lib/rollerskates/orm/associable.rb
+- lib/rollerskates/orm/helpers/database_table_helper.rb
+- lib/rollerskates/orm/helpers/query_helper.rb
+- lib/rollerskates/orm/query_builder.rb
 - lib/rollerskates/routing/mapper.rb
 - lib/rollerskates/routing/route.rb
 - lib/rollerskates/routing/router.rb

data/lib/rollerskates/helpers/model_helper.rb

@@ -1,92 +0,0 @@
-require "sqlite3"
-
-module Rollerskates
-  class ModelHelper
-    class << self; attr_accessor :properties, :db; end
-
-    def database
-      @db ||= SQLite3::Database.new File.join("db", "app.db")
-    end
-
-    def add_property(property)
-      self.class.properties ||= [
-        "id integer PRIMARY KEY AUTOINCREMENT",
-        "created_at datetime NOT NULL",
-        "updated_at datetime NOT NULL"
-      ]
-      self.class.properties << property
-    end
-
-    def self.property(field, options)
-      new.add_property "#{field} #{parse_constraints(options)}"
-    end
-
-    def self.create_table
-      query = "CREATE TABLE IF NOT EXISTS #{table_name}\
-              (#{properties.join(', ')})"
-      database.execute(query)
-
-      all_columns.each { |var| attr_accessor var }
-    end
-
-    def self.parse_constraints(constraints)
-      attributes = ""
-      constraints.each do |attr, value|
-        attributes += send(attr.to_s, value)
-      end
-
-      attributes
-    end
-
-    def self.type(value)
-      "#{value.to_s.upcase} "
-    end
-
-    def self.primary_key(value)
-      return "PRIMARY KEY " if value
-      " "
-    end
-
-    def self.nullable(value)
-      return "NOT NULL " if value
-      "NULL "
-    end
-
-    def self.default(value)
-      "DEFAULT `#{value}` "
-    end
-
-    def self.auto_increment(value)
-      "AUTOINCREMENT " if value
-    end
-
-    def update_query
-      "UPDATE #{table_name} SET #{placeholders_for_update} WHERE id = ?"
-    end
-
-    def table_name
-      self.class.to_s.downcase.pluralize
-    end
-
-    def model_name
-      self.class
-    end
-
-    def self.method_missing(method, *args)
-      new.send(method, *args)
-    end
-
-    def all_columns
-      @all_columns ||= database.prepare "SELECT * FROM #{table_name}"
-      @all_columns.columns.map(&:to_sym)
-    end
-
-    def method_missing(method, *args)
-      @model.send(method, *args)
-    end
-
-    def self.all_columns
-      new.all_columns
-    end
-  end
-end