feet 0.0.9 → 0.0.92

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a0c3e1fc4a9a9d0a621b09f655b3bb412c8244749215fefbbb70c51f3e6740c5
-  data.tar.gz: 589ddacf2c109fc9839adc44f4e1fbd41afc7e7e28cdf9907ad081fa58dd4e60
+  metadata.gz: f15402526d193d6dbbaae0faa7824b6f6c63fc5ebba323c0b5db44b861a4f72b
+  data.tar.gz: 76c466d6a6a7c11eb7f7499e7df7af429802a0aa8149da533d138231c89acb2e
 SHA512:
-  metadata.gz: 07ac4430315e10541fca8b034ad8e7e31f2b6bb49c640963d5442aa30dc7ab7535e8abeec83f4e15c9894d426221d004de9be983a0f56813acd127f21ea2fa42
-  data.tar.gz: aeebc7f4721d7c465b7471cc15e0912be86d2465a0468599cd7b80f09aeac25b894f6c16dd3abcb6a2a34c3448e45c484f3d3fb9035338b5dd7dc72c2f32670e
+  metadata.gz: e13310b0fce8c11163e5d7db16440e44379a6272b9a0a276b13ee96c07a8c5f7e839d008594b76799d4431b0e93ee18d49810e95c108d35102433636947c1895
+  data.tar.gz: e665d27bd3e05a42f259f550112d433f3e26bc0146e0bd7834da168a66471a2ef4276d10f711ef8b8c0dbda0195f8ee5b1dbf03640c90806a9fef6e054c88d65

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+feet-*.gem
+test.db

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.0.1] - 2022-10-10
+
+- Initial release

data/Gemfile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in feet.gemspec
+gemspec
+
+gem "rake", "~> 13.0"

data/Gemfile.lock

@@ -0,0 +1,43 @@
+PATH
+  remote: .
+  specs:
+    feet (0.0.92)
+      erubis
+      multi_json
+      rack (~> 2.2)
+      sqlite3
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    byebug (11.1.3)
+    coderay (1.1.3)
+    erubis (2.7.0)
+    method_source (1.0.0)
+    minitest (5.17.0)
+    multi_json (1.15.0)
+    pry (0.14.1)
+      coderay (~> 1.1)
+      method_source (~> 1.0)
+    pry-byebug (3.10.1)
+      byebug (~> 11.0)
+      pry (>= 0.13, < 0.15)
+    rack (2.2.5)
+    rack-test (2.0.2)
+      rack (>= 1.3)
+    rake (13.0.6)
+    sqlite3 (1.6.0-arm64-darwin)
+
+PLATFORMS
+  arm64-darwin-21
+  arm64-darwin-22
+
+DEPENDENCIES
+  feet!
+  minitest
+  pry-byebug
+  rack-test
+  rake (~> 13.0)
+
+BUNDLED WITH
+   2.3.17

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2022 Darius Pirvulescu
+
+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.md

@@ -0,0 +1,235 @@
+# Ruby on Feet
+This gem was developed part of a group study of the [Rebuilding Rails](https://rebuilding-rails.com/) book by [Noah Gibbs](https://github.com/noahgibbs).
+
+**Ruby on Feet** is a baby Rails-like MVC framework and replicates some of the main features of Rails (see Usage).
+
+<p align="center">
+  <img src="public/cover.png" width="250" height="446" />
+</p>
+
+## Installation
+
+In your Rack application, add `feet` in your Gemfile:
+
+```
+gem 'feet'
+```
+
+And then run `bundle install`
+ 
+Use Feet in your app. An example app:
+
+```ruby
+# config/application.rb
+require 'feet'
+$LOAD_PATH << File.join(File.dirname(__FILE__), '..', 'app',
+                        'controllers')
+
+module MyApp
+  class Application < Feet::Application; end
+end
+```
+
+Initialize the application in your rack config.ru. 
+
+```ruby
+# config.ru
+require './config/application'
+
+app = MyApp::Application.new
+
+run app
+```
+
+After, start the rackup and navigate to the `/feet` path to see Feet welcome page and more info.
+You can also check this Usage section for adding controllers and further configuring routes.
+
+
+## Usage
+
+This projects mocks different Rails features. After installing it in your personal project, you can check some example for each feature.
+
+<details>
+  <summary>Routing</summary>
+
+  Map different routes to their controller action.
+  Similar to Rails.
+
+  ```ruby
+  # config.ru
+  app.route do
+      root 'home#index'
+
+      match 'posts', 'posts#index'
+      match 'posts/:id', 'posts#new_post', via: 'POST' # Use different HTTP verb with the `via` option
+      match 'posts/:id', 'posts#show'
+
+      # Get all the default resources with the `resource` method
+      resource 'article'
+  
+      # Or just assign default routes
+      match ":controller/:id/:action.(:type)?"
+      match ':controller/:id/:action'
+      match ':controller/:id',
+              default: { 'action' => 'show' }
+
+  end
+  ```
+</details>
+
+<details>
+  <summary>Controllers</summary>
+  
+  ```ruby
+  # app/controllers/posts_controller.rb
+  class PostsController < Feet::Controller
+    def show
+      render :show
+    end
+
+    def index
+      render :index
+    end
+  end
+  ```
+</details>
+
+<details>
+    <summary>Views</summary>
+
+  ```ruby
+  # app/views/posts/show.html.erb
+  <h1><%= @post['title'] %></h1>
+  <p> <%= @post['body'] %></p>
+  ```
+</details>
+
+<details>
+  <summary>FileModel (for building basic file-base models)</summary>
+  <br />
+  Create a directory to store the files. Each file will be a row on the DB
+
+  The number in the file name will be the `id` of that record
+
+  ```ruby
+  # db/posts/1.json
+  {
+    "title": "Ruby on Feet",
+    "body": "..."
+  }
+  ```
+
+  Then use the `FileModel` to do CRUD operations
+
+  ```ruby
+  # app/controllers/post_controller.rb
+  def index
+      @posts = FileModel.all
+      render :index
+  end
+  ```
+</details>
+
+<details>
+    <summary>SQLiteModel ORM</summary>
+
+  First, create and run a mini migration to initiate the DB (test.db) and create the table (my_table). Modify the DB and table name.
+  ```ruby
+    # mini_migration.rb
+    require 'sqlite3'
+
+    conn = SQLite3::Database.new 'test.db'
+    conn.execute <<~SQL
+      create table my_table (
+        id INTEGER PRIMARY KEY,
+        posted INTEGER,
+        title VARCHAR(30),
+        body VARCHAR(32000)
+      );
+    SQL
+  ```
+  Run the migration
+
+    $ ruby mini_migration.rb
+
+  ```ruby
+  # app/my_table.rb
+  require 'feet/sqlite_model'
+
+  class MyTable < Feet::Model::SQLiteModel; end
+
+  # You can add a seed method on MyTable
+  MyTable.class_eval do
+    def self.seed
+      MyTable.create "title" => "Ruby on Feet", "posted" => 1,"body" => "..."
+    end
+  end
+  ```
+
+  Then you can use MyTable in your controller to handle your DB entries
+
+  ```ruby
+  # app/controller/post_controller.rb
+  require_relative '../my_table'
+  class PostsController < Feet::Controller
+      def show
+        @post = MyTable.find(params['id'])
+        render :show
+      end
+      def index
+          @posts = MyTable.all
+          render :index
+      end
+      def create
+        @post = MyTable.seed
+        render :show
+      end
+  end
+  ```
+
+</details>
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+Running `gem build feet.gemspec` will create a build file feet-VERSION.gem
+
+## Testing
+The [Minitest](http://docs.seattlerb.org/minitest/) library was used for testing.
+
+`Rake::TestTask` was configure to run the test suite. You can see a list of Rake commands with `rake -T`.
+
+Run all tests with:
+
+    $ rake test
+
+To run only one test, use:
+
+    $ rake test TEST=test/filename.rb
+
+
+Currently, the following test files are available:
+- application_test.rb
+- utils_test.rb
+- file_model_test.rb
+- sqlite_model_test.rb
+- route_test.rb
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/dariuspirvulescu/feet.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+
+<!-- TODO: -->
+<!-- Fix FileModel so to work with multiple models, not just quotes -->
+<!-- Remove @route comment from RouteObject -->
+<!-- Deploy the gem to rubygems org https://guides.rubygems.org/publishing/ -->
+<!-- CHECK README FOR ANY ERROR instructions -->
+<!-- Add content to the Welcome page -->

data/Rakefile

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.name = 'test'
+  t.libs << 'test'
+  t.test_files = Dir['test/*test*.rb']
+  t.verbose = true
+end

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "feet"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/feet.gemspec

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative 'lib/feet/version'
+
+Gem::Specification.new do |spec|
+  spec.name = 'feet'
+  spec.version = Feet::VERSION
+  spec.authors = ['Darius Pirvulescu']
+  spec.email = ['organicdarius@gmail.com']
+
+  spec.summary = 'Hairy rails twin'
+  spec.description = 'A more down to earth, hairy rails twin'
+  spec.homepage = 'https://i.etsystatic.com/13348558/r/il/a29ab1/2918306283/il_570xN.2918306283_ojql.jpg'
+  spec.license = 'MIT'
+  spec.required_ruby_version = '>= 2.6.0'
+
+  spec.metadata['allowed_push_host'] = 'https://rubygems.org/'
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = 'https://github.com/DariusPirvulescu/feet'
+  spec.metadata['changelog_uri'] = 'https://github.com/DariusPirvulescu/feet/pulls?q=is%3Apr+is%3Aclosed'
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir = 'exe'
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  # Uncomment to register a new dependency of your gem
+  # spec.add_dependency 'example-gem', '~> 1.0'
+
+  spec.add_runtime_dependency 'erubis'
+  spec.add_runtime_dependency 'multi_json'
+  spec.add_runtime_dependency 'rack', '~>2.2'
+  spec.add_runtime_dependency 'sqlite3'
+
+  spec.add_development_dependency 'minitest'
+  spec.add_development_dependency 'pry-byebug'
+  spec.add_development_dependency 'rack-test'
+
+  # For more information and examples about making a new gem, check out our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end

data/lib/feet/array.rb

@@ -0,0 +1,17 @@
+class Array
+  def deeply_empty?
+    empty? || all?(&:empty?)
+  end
+
+  def present?
+    !blank?
+  end
+
+  def blank?
+    respond_to?(:empty?) ? !!empty? : !self
+  end
+
+  def all_strings?
+    all?(String)
+  end
+end

data/lib/feet/controller.rb

@@ -0,0 +1,85 @@
+require 'erubis'
+require 'rack/request'
+require 'feet/file_model'
+require 'feet/view'
+
+module Feet
+  class Controller
+    include Feet::Model
+
+    def initialize(env)
+      @env = env
+      @routing_params = {}
+    end
+
+    def env
+      @env
+    end
+
+    def request
+      @request ||= Rack::Request.new(env)
+    end
+
+    def params
+      request.params.merge @routing_params
+    end
+
+    def build_response(text, status = 200, headers = {})
+      raise 'Already responded!' if @response
+
+      a = [text].flatten
+      @response = Rack::Response.new(a, status, headers)
+    end
+
+    def response
+      @response
+    end
+
+    def render_response(*args)
+      build_response(render(*args))
+    end
+
+    def class_name
+      self.class
+    end
+
+    def feet_version
+      Feet::VERSION
+    end
+
+    def controller_name
+      # self.class.to_s.split('Controller').first.downcase
+      klass = self.class
+      klass = klass.to_s.gsub(/Controller$/, '')
+      Feet.to_snake_case klass
+    end
+
+    def instance_hash
+      instance_variables.each_with_object(Hash.new('')) do |iv, hash|
+        hash[iv] = instance_variable_get iv
+      end
+    end
+
+    def render(view_name)
+      filename = File.join 'app', 'views', controller_name, "#{view_name}.html.erb"
+      template = File.read filename
+      View.new(template, instance_hash).call
+    end
+
+    def self.action(act, route_params = {})
+      proc { |e| self.new(e).dispatch(act, route_params) }
+    end
+
+    def dispatch(action, routing_params = {})
+      @routing_params = routing_params
+
+      text = send(action)
+      if response
+        [response.status, response.headers, [response.body].flatten]
+      else
+        [200, { 'Content-Type' => 'text/html' }, [text].flatten]
+      end
+
+    end
+  end
+end

data/lib/feet/dependencies.rb

@@ -0,0 +1,13 @@
+class Object
+  def self.const_missing(c)
+    @const_missing_called ||= {}
+    return nil if @const_missing_called[c]
+
+    @const_missing_called[c] = true
+    require Feet.to_snake_case(c.to_s)
+    klass = Object.const_get(c)
+    @const_missing_called[c] = false
+
+    klass
+  end
+end

data/lib/feet/file_model.rb

@@ -0,0 +1,125 @@
+require 'multi_json'
+
+module Feet
+  module Model
+    class FileModel
+      def initialize(filename)
+        @filename = filename
+
+        # If filename is "dir/21.json", @id is 21
+        basename = File.split(filename)[-1]
+        @id = File.basename(basename, '.json').to_i
+
+        row_object = File.read(filename)
+        @hash = MultiJson.load(row_object)
+      end
+
+      def [](name)
+        @hash[name.to_s]
+      end
+
+      def []=(name, value)
+        @hash[name.to_s] = value
+      end
+
+      def self.find(id)
+        id = id.to_i
+        @dm_style_cache ||= {}
+        begin
+          return @dm_style_cache[id] if @dm_style_cache[id]
+
+          found = FileModel.new("db/quotes/#{id}.json")
+          @dm_style_cache[id] = found
+          found
+        rescue Errno::ENOENT
+          nil
+        end
+      end
+
+      def self.all
+        files = Dir['db/quotes/*.json']
+        files.map { |f| FileModel.new f }
+      end
+
+      def self.create(attrs)
+        # Create hash
+        hash = {}
+        hash['attribution'] = attrs['attribution'] || ''
+        hash['submitter'] = attrs['submitter'] || ''
+        hash['quote'] = attrs['quote'] || ''
+
+        # Find highest id
+        files = Dir['db/quotes/*.json']
+        names = files.map { |f| File.split(f)[-1] } # transform to_i here?
+        highest = names.map(&:to_i).max
+        id = highest + 1
+
+        # Open and write the new file
+        new_filename = "db/quotes/#{id}.json"
+        File.open("db/quotes/#{id}.json", 'w') do |f|
+          f.write <<~TEMPLATE
+            {
+                "submitter": "#{hash['submitter']}",
+                "quote": "#{hash['quote']}",
+                "attribution": "#{hash['attribution']}"
+            }
+          TEMPLATE
+        end
+
+        # Create new FileModel instance with the new file
+        FileModel.new new_filename
+      end
+
+      def save
+        return 'No valid hash' unless @hash
+
+        # Write JSON to file
+        File.open(@filename, 'w') do |f|
+          f.write <<~TEMPLATE
+            {
+                "submitter": "#{@hash['submitter']}",
+                "quote": "#{@hash['quote']}",
+                "attribution": "#{@hash['attribution']}"
+            }
+          TEMPLATE
+        end
+
+        # Return the hash
+        @hash
+      end
+
+      def self.find_all_by_attribute(attribute, value)
+        id = 1
+        results = []
+        loop do
+          model = find(id)
+          return results unless model
+
+          results.push(model) if model[attribute] == value
+          id += 1
+        end
+      end
+
+      def self.find_all_by_submitter(name = '')
+        return [] unless name
+
+        find_all_by_attribute('submitter', name)
+      end
+
+      def self.method_missing(m, *args)
+        base = /^find_all_by_(.*)/
+        if m.to_s.start_with? base
+          key = m.to_s.match(base)[1]
+          find_all_by_attribute(key, args[0])
+        else
+          super
+        end
+      end
+
+      def self.respond_to_missing?(method_name, include_private = false)
+        method_name.to_s.start_with?('find_all_by') || super
+      end
+
+    end
+  end
+end

data/lib/feet/routing.rb

@@ -0,0 +1,141 @@
+module Feet
+  class RouteObject
+    def initialize
+      @rules = []
+      @default_rules = [
+        {
+          regexp: /^\/([a-zA-Z0-9]+)$/,
+          vars: ['controller'],
+          dest: nil,
+          via: false,
+          options: { default: { 'action' => 'index' } }
+        }
+      ]
+    end
+
+    def root(*args)
+      match('', *args)
+    end
+
+    def resource(name)
+      match "/#{name}", default: { 'action' => 'index' }, via: 'GET'
+      match "/#{name}/new", default: { 'action' => 'new' }, via: 'GET'
+      match "/#{name}", default: { 'action' => 'create' }, via: 'POST'
+      match "/#{name}/:id", default: { 'action' => 'show' }, via: 'GET'
+      match "/#{name}/:id/edit", default: { 'action' => 'edit' }, via: 'GET'
+      match "/#{name}/:id", default: { 'action' => 'update' }, via: 'PUT'
+      match "/#{name}/:id", default: { 'action' => 'update' }, via: 'PATCH'
+      match "/#{name}/:id", default: { 'action' => 'destroy' }, via: 'DELETE'
+    end
+
+    # Example arguments
+    # url  ":controller/:id"
+    # args [{:default=>{"action"=>"show"}}]
+    def match(url, *args)
+      # Capture the options hash
+      options = {}
+      options = args.pop if args[-1].is_a? Hash
+      # Check for default option
+      options[:default] ||= {}
+
+      # Get destination and limit the # of arguments
+      dest = nil
+      dest = args.pop if args.size > 0
+      raise 'Too many arguments!' if args.size > 0
+
+      # Parse URL parts. Split on appropriate punctuation
+      # (slash, parens, question mark, dot)
+      parts = url.split /(\/|\(|\)|\?|\.)/
+      parts.reject! { |p| p.empty? }
+
+      vars = []
+      regexp_parts = parts.map do |part|
+        case part[0]
+        when ':'
+          # Map Variable
+          vars << part[1..-1]
+          '([a-zA-Z0-9]+)?'
+        when '*'
+          # Map Wildcard
+          vars << part[1..-1]
+          '(.*)'
+        when '.'
+          '\\.' # Literal dot
+        else
+          part
+        end
+      end
+
+      # Join the main regexp
+      regexp = regexp_parts.join('')
+
+      # Store match object
+      @rules.push({
+                    regexp: Regexp.new("^/#{regexp}$"),
+                    vars: vars,
+                    dest: dest,
+                    via: options[:via] ? options[:via].downcase : false,
+                    options: options
+                  })
+    end
+
+    def check_url(url, method)
+      (@rules + @default_rules).each do |rule|
+        next if rule[:via] && rule[:via] != method.downcase
+
+        # Check if rule against regexp
+        matched_data = rule[:regexp].match(url)
+
+        if matched_data
+          # Build params hash
+          options = rule[:options]
+          params = options[:default].dup
+
+          # Match variable names with the regexp captured parts
+          rule[:vars].each_with_index do |var, i|
+            params[var] = matched_data.captures[i]
+          end
+
+          if rule[:dest]
+            # There's either a destination like 'controller#action' or a Proc
+            return get_dest(rule[:dest], params)
+          else
+            # The params are specified in the options[:default]
+            # Use controller#action to get the Rack application
+            controller = params['controller']
+            action = params['action']
+            return get_dest("#{controller}##{action}", params)
+          end
+        end
+      end
+      nil
+    end
+
+    # Returns a Rack application or raises an error if no/invalid 'dest'
+    def get_dest(dest, routing_params = {})
+      return dest if dest.respond_to?(:call)
+
+      # Ex 'controller#action'
+      if dest =~ /^([^#]+)#([^#]+)$/
+        name = $1.capitalize
+        controller = Object.const_get("#{name}Controller")
+        return controller.action($2, routing_params)
+      end
+
+      raise "No destination: #{dest.inspect}!"
+    end
+  end
+
+  class Application
+    def route(&block)
+      @route_obj ||= RouteObject.new
+      @route_obj.instance_eval(&block)
+    end
+
+    def get_rack_app(env)
+      raise 'No routes!' unless @route_obj
+
+      @route_obj.check_url env['PATH_INFO'], env['REQUEST_METHOD']
+    end
+  end
+end

data/lib/feet/sqlite_model.rb

@@ -0,0 +1,142 @@
+require 'sqlite3'
+require 'feet/utils'
+
+DB = SQLite3::Database.new 'test.db'
+
+module Feet
+  module Model
+    class SQLiteModel
+      def initialize(data = nil)
+        @hash = data
+      end
+
+      def self.table
+        Feet.to_snake_case name # name = method to return the class name, ex: MyName
+      end
+
+      def self.schema
+        return @schema if @schema
+
+        @schema = {}
+        DB.table_info(table) do |row|
+          @schema[row['name']] = row['type']
+        end
+
+        @schema
+      end
+
+      def self.to_sql(value)
+        case value
+        when NilClass
+          'null'
+        when Numeric
+          value.to_s
+        when String
+          "'#{value}'"
+        else
+          raise "Can't convert #{value.class} to SQL."
+        end
+      end
+
+      def self.create(initial_hash)
+        # Get initial_hash and schema keys without ids and map initial_hash to schema keys
+        initial_hash.delete 'id'
+        keys = schema.keys - ['id']
+        sql_values = keys.map do |key|
+          initial_hash[key] ? to_sql(initial_hash[key]) : 'null'
+        end
+
+        # Insert values into table
+        DB.execute <<~SQL
+          INSERT INTO #{table} (#{keys.join ','}) VALUES (#{sql_values.join ','});
+        SQL
+
+        # Build and return the new table entry
+        raw_values = keys.map { |k| initial_hash[k] }
+        data = Hash[keys.zip raw_values]
+
+        # Get the latest id
+        sql = 'SELECT last_insert_rowid();'
+        data['id'] = DB.execute(sql)[0][0]
+
+        self.new data
+      end
+
+      def self.find(id)
+        keys = schema.keys
+        response = DB.execute <<~SQL
+          SELECT #{keys.join ','} FROM #{table} WHERE id = #{id}
+        SQL
+        return nil unless response[0]
+
+        data = Hash[keys.zip response[0]]
+        self.new data
+      end
+
+      def [](name)
+        @hash[name.to_s]
+      end
+
+      def []=(key, value)
+        @hash[key] = value
+      end
+
+      def save!
+        return nil unless @hash['id']
+
+        hash_map = @hash.keys.map do |key|
+          "#{key} = #{self.class.to_sql(@hash[key])}"
+        end
+
+        DB.execute <<~SQL
+          UPDATE #{self.class.table}
+          SET #{hash_map.join ','}
+          WHERE id = #{@hash['id']};
+        SQL
+        @hash
+      end
+
+      def self.all
+        keys = schema.keys
+        rows = DB.execute <<~SQL
+          SELECT * FROM #{table}
+        SQL
+
+        rows.map do |row|
+          data = Hash[keys.zip row]
+          self.new data
+        end
+      end
+
+      def self.count
+        db_result = DB.execute <<~SQL
+          SELECT COUNT(*) FROM #{table};
+        SQL
+        db_result[0][0]
+      end
+
+      def method_missing(method, *args)
+        # Check for getter
+        if @hash[method.to_s]
+          self.class.define_method(method) do
+            self[method]
+          end
+          return send(method)
+        end
+
+        # Check for setters
+        if method.to_s[-1..-1] == '='
+          field = method.to_s[0..-2]
+          self.class.class_eval do
+            define_method(method) do |value|
+              self[field] = value
+            end
+          end
+          return self.send(method, args[0])
+        end
+
+        super
+      end
+    end
+  end
+end

data/lib/feet/utils.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Feet
+  def self.to_snake_case(string)
+    string.gsub(/::/, '/') # to remove the subdirectory feature
+          .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+          .gsub(/([a-z\d])([A-Z][a-z])/, '\1_\2')
+          .tr('-', '_')
+          .downcase
+  end
+end

data/lib/feet/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Feet
+  VERSION = '0.0.92'
+end

data/lib/feet/view.rb

@@ -0,0 +1,28 @@
+require 'erubis'
+
+module Feet
+  class View
+    def initialize(template, instance_hash)
+      @template = template
+      init_vars(instance_hash)
+    end
+
+    def call
+      eruby = Erubis::Eruby.new(@template)
+      # Locals here are in addition to instance variables, if any
+      eval eruby.src
+    end
+
+    def init_vars(received_vars)
+      received_vars.each do |key, value|
+        # key example = '@quote'
+        instance_variable_set(key, value)
+      end
+    end
+
+    # Helper method for View
+    def h(str)
+      URI.escape str
+    end
+  end
+end

data/lib/feet.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative 'feet/version'
+require 'feet/array'
+require 'feet/routing'
+require 'feet/dependencies'
+require 'feet/controller'
+require 'feet/utils'
+
+module Feet
+  class Error < StandardError; end
+
+  class Application
+    def call(env)
+      return [404, { 'Content-Type' => 'text/html' }, []] if env['PATH_INFO'] == '/favicon.ico'
+
+      # Assign a default Feet HTML welcome page (in public/index.html)
+      if env['PATH_INFO'] == '/feet'
+        path = File.expand_path('../public/index.html', __dir__)
+        return [200, { 'Content-Type' => 'text/html' }, File.open(path)]
+      end
+
+      rack_app = get_rack_app(env)
+      rack_app.call(env)
+    end
+  end
+end

data/public/index.html

@@ -0,0 +1,13 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta http-equiv="X-UA-Compatible" content="IE=edge">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Immanuel Kan</title>
+</head>
+<body>
+  <h1>Ruby on Feet</h1>
+  <h2>Welcome</h2>
+</body>
+</html>

data/sig/feet.rbs

@@ -0,0 +1,4 @@
+module Feet
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: feet
 version: !ruby/object:Gem::Version
-  version: 0.0.9
+  version: 0.0.92
 platform: ruby
 authors:
 - Darius Pirvulescu
@@ -114,7 +114,30 @@ email:
 executables: []
 extensions: []
 extra_rdoc_files: []
-files: []
+files:
+- ".gitignore"
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- feet.gemspec
+- lib/feet.rb
+- lib/feet/array.rb
+- lib/feet/controller.rb
+- lib/feet/dependencies.rb
+- lib/feet/file_model.rb
+- lib/feet/routing.rb
+- lib/feet/sqlite_model.rb
+- lib/feet/utils.rb
+- lib/feet/version.rb
+- lib/feet/view.rb
+- public/cover.png
+- public/index.html
+- sig/feet.rbs
 homepage: https://i.etsystatic.com/13348558/r/il/a29ab1/2918306283/il_570xN.2918306283_ojql.jpg
 licenses:
 - MIT