trails-mvc 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1244b83c70f9e9af3cfe1e9a7c44131e47ba9844
+  data.tar.gz: b8c8cd33e4451828db4f3440f5c61bb37ac3b2de
+SHA512:
+  metadata.gz: 35083d83c3cc7b54efdce5205384e61d2fe354c8c0e59e2a4c1e28f754a4c3fdb2268ffed0842f66ea3d71238ff6b8b029fbd3ca35f60c775e5bfbd86aedf872
+  data.tar.gz: 9873a3e4b9e4bdc9f3964a7a83e65515a6691e9c5669a25d83762e255c1f2d53f6b51dc03d9685fcbc210820df0e7892052ae84844dfb3dba4d74aac937ce6c8

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format documentation

data/Gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+gemspec
+gem 'bcrypt'
+gem 'byebug'

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 William McMeans
+
+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,74 @@
+# Ruby on Trails
+## What is Ruby on Trails?
+**[View the Sample App Live](http://www.ruby-on-trails.com/)**
+
+**[Trails Sample App Repository](https://github.com/wmcmeans/trails-sample)
+to see how to use Trails**
+
+Trails is a lightweight MVC framework built in Ruby by
+[Will McMeans](https://github.com/wmcmeans). It is similar in functionality to Ruby on
+Rails, but flavored the way I like it. It features a custom ORM called [Dynamic
+Archive](https://github.com/wmcmeans/dynamic-archive) (doesn't that sound more
+exciting than Active Record?) and everything else you need to build a simple web
+app. We're not riding rails...we're hiking trails!
+
+## How to Get Started
+### Install the Trails Gem
+`gem install trails-mvc`
+
+### Create Your First App
+`trails new <name>` — begins a new Trails project
+
+### Start the Server
+`trails server [--host] [--port]` — starts the Trails server; default host: localhost,
+default port: 3000
+
+### Generate Models and Controllers
+`trails generate model <model_name>` — creates a new model file in `app/models` and a new migration in `db/migrations`
+
+`trails generate controller <controller_name>` — creates a new controller file in
+`app/controllers` and a corresponding view folder in `app/views`
+
+`trails generate migration <migration_name>` — creates a blank migration file in
+`db/migrations` (but no model file)
+
+### Change the Database
+`trails db reset` — clears the database, runs all migrations, and re-seeds
+
+`trails db migrate` — runs all pending database migrations
+
+`trails db seed` — seeds the database
+
+### Add Routes
+Follow the example in `config/routes.rb`
+
+### Add CSS and JavaScript
+It's recommended to add styling to `public/assets/application.css` and any JavaScript
+to `public/assets/application.js`. You may also include other scripts and stylesheets
+in your views as long as you store them in `public/assets`.
+
+### Not Sure What to do Next?
+**Check out the [Trails Sample App Repository](https://github.com/wmcmeans/trails-sample)
+to get a better idea of what you can do with Ruby on Trails**
+
+## Features
+* [Dynamic Archive (Custom ORM)](https://github.com/wmcmeans/dynamic-archive)
+creates rich relationships between objects.
+* [`Server`](bin/server.rb) handles requests and creates responses, nesting the main
+app within a `Rack::Builder` instance that contains middleware (e.g. a StackAssetsServer
+  that serves stylesheets).
+* [`Router`](lib/router.rb) uses routes to direct requests to controllers.
+* [`TrailsController::Base`](lib/controller_base.rb) builds responses based on
+parameters and renders content using `ERB` views, including partials.
+* [`Session`](lib/session.rb) sets and reads cookies to persist data between
+requests
+* [`Flash`](lib/flash.rb) a special type of information that lives for only one
+subsequent request (or just the current one, if using `Flash#now`).
+
+## Technologies
+* Ruby
+* Rack
+* ERB
+* SQLite3
+* Thor
+* JSON

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "trails"
+
+# 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

data/bin/server.rb

@@ -0,0 +1,31 @@
+require 'rack'
+
+class TrailsServer
+  def initialize(port, host)
+    @port = port
+    @host = host
+    router = Router.new
+    router.draw(&ROUTES)
+
+    trails_app = Proc.new do |env|
+      req = Rack::Request.new(env)
+      res = Rack::Response.new
+      router.run(req, res)
+      res.finish
+    end
+
+    @app = Rack::Builder.new do
+      use StaticAssetsServer
+      use Rack::MethodOverride
+      run trails_app
+    end
+  end
+
+  def start
+    Rack::Server.start(
+      app: @app,
+      Port: @port,
+      Host: @host
+    )
+  end
+end

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/bin/trails

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby -U
+require 'trails'
+
+Trails::CLI.start(ARGV)

data/dynamic-archive/.rspec

@@ -0,0 +1,2 @@
+--color
+--format documentation

data/dynamic-archive/.ruby-version

@@ -0,0 +1 @@
+2.3.0

data/dynamic-archive/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+gem 'activesupport'
+gem 'rspec', '~> 3.1.0'
+gem 'sqlite3'
+gem 'byebug'

data/dynamic-archive/Gemfile.lock

@@ -0,0 +1,38 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (4.0.3)
+      i18n (~> 0.6, >= 0.6.4)
+      minitest (~> 4.2)
+      multi_json (~> 1.3)
+      thread_safe (~> 0.1)
+      tzinfo (~> 0.3.37)
+    byebug (8.2.1)
+    diff-lcs (1.2.5)
+    i18n (0.6.9)
+    minitest (4.7.5)
+    multi_json (1.10.1)
+    rspec (3.1.0)
+      rspec-core (~> 3.1.0)
+      rspec-expectations (~> 3.1.0)
+      rspec-mocks (~> 3.1.0)
+    rspec-core (3.1.7)
+      rspec-support (~> 3.1.0)
+    rspec-expectations (3.1.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.1.0)
+    rspec-mocks (3.1.3)
+      rspec-support (~> 3.1.0)
+    rspec-support (3.1.2)
+    sqlite3 (1.3.9)
+    thread_safe (0.3.4)
+    tzinfo (0.3.39)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activesupport
+  byebug
+  rspec (~> 3.1.0)
+  sqlite3

data/dynamic-archive/README.md

@@ -0,0 +1,40 @@
+# Dynamic Archive
+Dynamic Archive is a Object-Relational Mapping system written in Ruby. It facilitates
+storage of complex programming objects in databases. Information about objects are
+stored in tables and retrieved from the database as needed and re-instantiated as
+Ruby objects. Custom SQL queries allows for elaborate relationships between objects
+to easily be formed.
+
+The core of Dynamic Archive lives in [lib](./lib). Dynamic Archive plays a major role
+as part of [Ruby on Trails](https://github.com/wmcmeans/trails).
+
+## [DynamicArchive::Base](./lib/base.rb)
+
+The `Base` class is the core of Dynamic Archive. The class creates attribute methods based
+on column names in the `::finalize` method. This way, all classes that inherit will have
+instance methods for properties, e.g. how you can call something like `User#name`
+(and also `User#name=`).
+
+Base also has some SQL query methods, like `::find` that take an ID and return the first
+result from the database (or nil). The `#save` method nicely packages up the `update`
+and `insert` methods as one, even though the two require two different query strings.
+
+## Associatable, Searchable, Validatable
+
+These modules are extended to the `Base` class and make it more powerful.
+
+### [DynamicArchive::Associatable](./lib/associatable.rb)
+`Associatable` allows rich relationships to be formed between objects of different classes.
+Its `::has_many`,`::belongs_to`, `::has_one_through`, and `::has_many_through` methods
+can generate a complex mapping of interelation.
+
+### [DynamicArchive::Searchable](./lib/searchable.rb)
+As the name suggests, `Searchable` gives extra SQL searching capabilities most notably
+through its `::where` method that allows querying using an interpolated query string or
+with a hash of params.
+
+### [DynamicArchive::Validatable](./lib/validatable.rb)
+`Validatable` gives the option of adding validations to class attributes.
+`::validates` adds a list of attributes to be validated followed by a hash of validations
+to check for each. Basic validations such as `length`, `presence`, and `uniqueness`
+are included.

data/dynamic-archive/lib/associatable.rb

@@ -0,0 +1,145 @@
+module DynamicArchive
+  class AssocOptions
+    attr_accessor(
+      :foreign_key,
+      :class_name,
+      :primary_key
+    )
+
+    def model_class
+      class_name.constantize
+    end
+
+    def table_name
+      model_class.table_name
+    end
+  end
+
+  class BelongsToOptions < DynamicArchive::AssocOptions
+    def initialize(name, options = {})
+      defaults = {
+        foreign_key: "#{name.to_s.underscore}_id".to_sym,
+        primary_key: :id,
+        class_name:  name.to_s.camelcase
+      }
+      options = defaults.merge(options)
+
+      @foreign_key = options[:foreign_key]
+      @primary_key = options[:primary_key]
+      @class_name  = options[:class_name]
+    end
+  end
+
+  class HasManyOptions < DynamicArchive::AssocOptions
+    def initialize(name, self_class_name, options = {})
+      defaults = {
+        foreign_key: "#{self_class_name.to_s.underscore}_id".to_sym,
+        primary_key: :id,
+        class_name: name.to_s.singularize.camelcase
+      }
+      options = defaults.merge(options)
+
+      @foreign_key = options[:foreign_key]
+      @primary_key = options[:primary_key]
+      @class_name  = options[:class_name]
+    end
+  end
+
+  module Associatable
+    def assoc_options
+      @assoc_options ||= {}
+    end
+
+    def belongs_to(name, options = {})
+      options = BelongsToOptions.new(name, options)
+      assoc_options[name] = options
+
+      define_method(name) do
+        foreign_key_val = self.send(options.foreign_key)
+
+        options.model_class.where(options.primary_key => foreign_key_val).first
+      end
+
+    end
+
+    def has_many(name, options = {})
+      options = HasManyOptions.new(name, self.to_s, options)
+      assoc_options[name] = options
+
+      define_method(name) do
+        foreign_key_val = self.send(options.primary_key)
+
+        options.model_class.where(options.foreign_key => foreign_key_val)
+      end
+    end
+
+    def has_one_through(name, through_name, source_name)
+      through_options = self.assoc_options[through_name]
+      source_options = through_options.model_class.assoc_options[source_name]
+
+      define_method(name) do
+        key = send(through_options.foreign_key)
+        # use `LIKE` to workaround SQLite bug
+        results = DBConnection.execute(<<-SQL, key)
+          SELECT
+            #{source_options.table_name}.*
+          FROM
+            #{through_options.table_name}
+          JOIN
+            #{source_options.table_name}
+          ON
+            #{through_options.table_name}.#{source_options.foreign_key} LIKE
+            #{source_options.table_name}.#{source_options.primary_key}
+          WHERE
+            #{through_options.table_name}.#{through_options.primary_key} LIKE ?
+        SQL
+
+        source_options.model_class.parse_all(results).first
+      end
+    end
+
+    def has_many_through(name, through_name, source_name)
+      through_options = self.assoc_options[through_name]
+      source_options = through_options.model_class.assoc_options[source_name]
+
+      define_method(name) do
+        if source_options.is_a?(HasManyOptions)
+          key = send(through_options.primary_key)
+          # use `LIKE` to workaround SQLite bug
+          results = DBConnection.execute(<<-SQL, key)
+            SELECT
+              #{source_options.table_name}.*
+            FROM
+              #{through_options.table_name}
+            JOIN
+              #{source_options.table_name}
+            ON
+              #{through_options.table_name}.#{source_options.primary_key} LIKE
+              #{source_options.table_name}.#{source_options.foreign_key}
+            WHERE
+              #{through_options.table_name}.#{through_options.foreign_key} LIKE ?
+          SQL
+
+        else
+          key = send(through_options.primary_key)
+          # use `LIKE` to workaround SQLite bug
+          results = DBConnection.execute(<<-SQL, key)
+            SELECT
+              #{source_options.table_name}.*
+            FROM
+              #{through_options.table_name}
+            JOIN
+              #{source_options.table_name}
+            ON
+              #{through_options.table_name}.#{source_options.foreign_key} LIKE
+              #{source_options.table_name}.#{source_options.primary_key}
+            WHERE
+              #{through_options.table_name}.#{through_options.foreign_key} LIKE ?
+          SQL
+        end
+
+        source_options.model_class.parse_all(results)
+      end
+    end
+  end
+end

data/dynamic-archive/lib/base.rb

@@ -0,0 +1,143 @@
+require_relative 'db_connection'
+require_relative 'associatable'
+require_relative 'searchable'
+require_relative 'validatable'
+require 'active_support/inflector'
+
+module DynamicArchive
+  class Base
+    extend DynamicArchive::Searchable
+    extend DynamicArchive::Associatable
+    extend DynamicArchive::Validatable
+
+    def self.columns
+      @columns ||= DBConnection.execute2(<<-SQL).first.map(&:to_sym)
+        SELECT
+          *
+        FROM
+          #{table_name}
+      SQL
+    end
+
+    def self.finalize!
+      columns.each do |column|
+        define_method("#{column}=") do |message|
+          attributes[column] = message
+        end
+
+        define_method("#{column}") do
+          attributes[column]
+        end
+      end
+    end
+
+    def self.table_name=(table_name)
+      @table_name = table_name
+    end
+
+    def self.table_name
+      @table_name ||= self.to_s.tableize
+    end
+
+    def self.all
+      results = DBConnection.execute(<<-SQL)
+        SELECT
+          *
+        FROM
+          #{table_name}
+      SQL
+      parse_all(results)
+    end
+
+    def self.parse_all(results)
+      results.map do |result|
+        params = {}
+        result.each do |key, value|
+          params[key.to_sym] = value
+        end
+        self.new(params)
+      end
+    end
+
+    def self.find(id)
+      results = DBConnection.execute(<<-SQL, id.to_i)
+        SELECT
+          *
+        FROM
+          #{table_name}
+        WHERE
+          id = (?)
+      SQL
+      parse_all(results).first
+    end
+
+    def initialize(params = {})
+      @validations = Hash.new { |h, k| h[k] = {} }
+
+      params.each do |key, val|
+        attr_name = key.to_sym
+        unless self.class.columns.include?(key) || self.class.method_defined?("#{attr_name}=")
+          raise "unknown attribute '#{attr_name}'"
+        end
+        self.send("#{attr_name}=", val)
+      end
+    end
+
+    def attributes
+      @attributes ||= {}
+    end
+
+    def attribute_values
+      self.class.columns.map do |attr|
+        self.send(attr)
+      end
+    end
+
+    def insert
+      col_names = self.class.columns.join(", ")
+      question_marks = (["?"] * self.class.columns.length).join(", ")
+      DBConnection.execute(<<-SQL, attribute_values)
+        INSERT INTO
+          #{self.class.table_name} (#{col_names})
+        VALUES
+          (#{question_marks})
+      SQL
+      self.id = DBConnection.last_insert_row_id
+    end
+
+    def update
+      set_line = self.class.columns.map { |col| "#{col} = (?)"}.join(", ")
+      DBConnection.execute(<<-SQL, attribute_values)
+        UPDATE
+          #{self.class.table_name}
+        SET
+          #{set_line}
+        WHERE
+          id = #{id}
+      SQL
+    end
+
+    def save
+      if self.class.is_valid?(self)
+        id.nil? ? insert : update
+      else
+        false
+      end
+    end
+
+    def destroy
+      DBConnection.execute(<<-SQL, self.id)
+        DELETE FROM
+          #{self.class.table_name}
+        WHERE
+          id = (?)
+      SQL
+
+      self
+    end
+
+    def errors
+      @errors ||= []
+    end
+  end
+end