feet 0.0.9 → 0.0.91

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a0c3e1fc4a9a9d0a621b09f655b3bb412c8244749215fefbbb70c51f3e6740c5
-  data.tar.gz: 589ddacf2c109fc9839adc44f4e1fbd41afc7e7e28cdf9907ad081fa58dd4e60
+  metadata.gz: 07d443fe7489fa46e75573a051cbaea50d5ed5fc4e48cfa37c5d3dc9722bc7c1
+  data.tar.gz: af25d58693e016b1cde6ed04bc0dce7456c38713851a79b482f40f74fd78d18e
 SHA512:
-  metadata.gz: 07ac4430315e10541fca8b034ad8e7e31f2b6bb49c640963d5442aa30dc7ab7535e8abeec83f4e15c9894d426221d004de9be983a0f56813acd127f21ea2fa42
-  data.tar.gz: aeebc7f4721d7c465b7471cc15e0912be86d2465a0468599cd7b80f09aeac25b894f6c16dd3abcb6a2a34c3448e45c484f3d3fb9035338b5dd7dc72c2f32670e
+  metadata.gz: 22ec8f8cb0f7636e9382fa428c7df6a43f6e07f936309105e4a28b329d08c6bf66f9b952a9fc121c8422b8406fa521b88065cae5d2d113bbf8caea5f7cba7a2e
+  data.tar.gz: fa8f9fe9fc8685542a2d1d8b42063cf76a0f38fd20b0bfd88cd76ce5ad4572ffc34f9162e830faa8aedc400dec9d5f37b48cdde906fa95c3885202e8eb0a3d23

data/CHANGELOG.md

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

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/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/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.91'
+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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: feet
 version: !ruby/object:Gem::Version
-  version: 0.0.9
+  version: 0.0.91
 platform: ruby
 authors:
 - Darius Pirvulescu
@@ -114,7 +114,21 @@ email:
 executables: []
 extensions: []
 extra_rdoc_files: []
-files: []
+files:
+- CHANGELOG.md
+- README.md
+- bin/console
+- bin/setup
+- 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
 homepage: https://i.etsystatic.com/13348558/r/il/a29ab1/2918306283/il_570xN.2918306283_ojql.jpg
 licenses:
 - MIT