tgauge 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d5d4baf3c8db65764294e937b63e35329622aa02
+  data.tar.gz: d91028cb4530550397075d31af4b18230c5cd9c9
+SHA512:
+  metadata.gz: 190e0c6bc495d2d0f3e065471656f1c5ed0ac479624a20b3a7528529fbea151ed3cd109ad65b9c5a1c84a176e648a0475ae191d163e842b72e8b96911b5a192e
+  data.tar.gz: 8913871c7735f2c118ef88daaeb5a5344b2d7bf12d89b5efc5208567804fb5900709c02052058ccb61f4d5415a93406291a4e48f1497e5aa7e1cb0def388f1f7

data/.gitignore

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

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in TGauge.gemspec
+gemspec

data/README.md

@@ -0,0 +1,36 @@
+# TGauge
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/TGauge`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'TGauge'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install TGauge
+
+## Usage
+
+TODO: Write usage instructions here
+
+## 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 tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/TGauge.
+

data/Rakefile

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

data/TGauge.gemspec

@@ -0,0 +1,40 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "tgauge"
+  spec.version       = TGauge::VERSION
+  spec.authors       = ["Nam Kim"]
+  spec.email         = ["nryulkim@gmail.com"]
+
+  spec.summary       = %q{Simple Ruby ORM and MVC}
+  spec.description   = %q{Allows you to build a simple webapp}
+  spec.homepage      = "https://github.com/nryulkim/tgauge"
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata['allowed_push_host'] = "https://rubygems.org"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against " \
+      "public gem pushes."
+  end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.13"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_runtime_dependency 'thor', '~> 0.19'
+  spec.add_runtime_dependency 'pg', '~> 0.18'
+  spec.add_runtime_dependency 'activesupport', '~> 4.2', '>= 4.2.5.1'
+  spec.add_runtime_dependency 'rack', '~> 1.6', '>=1.6.4'
+  spec.add_runtime_dependency 'fileutils', '~> 0.7'
+end

data/bin/console

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

@@ -0,0 +1,119 @@
+require 'rubygems'
+require 'thor'
+require 'active_support/inflector'
+#Generates models, controllers, and migrations. Alias 'g'
+class Generate < Thor
+  desc 'model <name>', 'generate a model.'
+  def model(name)
+    File.open('./app/models/#{name.downcase}.rb', 'w') do |f|
+      f.write("class #{name.capitalize} < TGauge::TRecordBase\n\n")
+      f.write("end\n")
+      f.write("#{name.capitalize}.finalize!")
+    end
+
+    migration("Create#{name.capitalize}}")
+    puts "#{name} model created"
+  end
+
+  desc 'controller <name>', 'generate a controller.'
+  def controller(name)
+    File.open('./app/controllers/#{name.downcase}.rb', 'w') do |f|
+      f.write("class #{name.capitalize}Controller < TGauge::TControllerBase\n\n")
+      f.write("end")
+    end
+
+    Dir.mkdir "./app/views/#{name.downcase}_controller"
+    puts "#{name} controller created"
+  end
+
+  desc 'migration <name>', 'generate an empty sql file.'
+  def migration(name)
+    #timestamp
+    ts = Time.now.to_i
+    filename = "#{ts}_#{name.underscore.downcase}"
+
+    File.open('./db/migrations/#{filename}.sql', 'w') do |f|
+      f.write "CREATE TABLE IF NOT EXISTS #{name} (\n"
+      f.write "\tid SERIAL PRIMARY KEY,\n"
+      f.write ')'
+    end
+  end
+end
+
+class Db < Thor
+  desc 'create', 'creates the DB'
+  def create
+    require_relative '../lib/db_connection'
+    TGauge::DBConnection.reset
+    puts 'db created!'
+  end
+
+  desc 'migrate', 'runs pending migrations'
+  def migrate
+    # Creates Version table if necessary,
+    # then runs needed migrations in order.
+    require_relative '../lib/db_connection'
+    TGauge::DBConnection.migrate
+    puts 'migrated!'
+  end
+
+  desc 'seed', 'seeds the DB'
+  def seed
+    require_relative '../lib/puffs'
+    TGauge::Seed.populate
+    puts 'db seeded!'
+  end
+
+  desc 'reset', 'resets the DB and seeds it'
+  def reset
+    create
+    migrate
+    seed
+    puts 'db reset!'
+  end
+end
+
+#top level commands
+class CLI < Thor
+  register(Generate, 'generate', 'generate <command>', 'Generates a model, migration, or controller.')
+  register(Db, 'db', 'db <command>', 'Accesses commands for the DB.')
+
+  subcommand 'g', Generate
+
+  desc 'server', 'starts the WebBrick server'
+  def server
+    require_relative '../lib/tgauge.rb'
+    TGauge::Server.start
+  end
+
+  desc 'new', 'creates a new TGauge app'
+  def new(name)
+    Dir.mkdir "./#{name}"
+    Dir.mkdir "./#{name}/config"
+
+    File.open("./#{name}/config/database.yml", 'w') do |f|
+      f.write("database: #{name}")
+    end
+
+    Dir.mkdir "./#{name}/app"
+    Dir.mkdir "./#{name}/app/models"
+    Dir.mkdir "./#{name}/app/views"
+    Dir.mkdir "./#{name}/app/controllers"
+    File.open("./#{name}/app/controllers/application_controller.rb", 'w') do |f|
+      f.write File.read(File.expand_path('../../lib/template/app/controllers/application_controller.rb', __FILE__))
+    end
+    File.open("./#{name}/config/routes.rb", 'w') do |f|
+      f.write File.read(File.expand_path('../../lib/template/config/routes.rb', __FILE__))
+    end
+    Dir.mkdir "./#{name}/db"
+    Dir.mkdir "./#{name}/db/migrations"
+    File.open("./#{name}/db/seeds.rb", 'w') do |f|
+      f.write File.read(File.expand_path('../../lib/template/db/seeds.rb', __FILE__))
+    end
+    File.open("./#{name}/Gemfile", 'w') do |f|
+      f.write File.read(File.expand_path('../../lib/template/Gemfile', __FILE__))
+    end
+  end
+end
+
+CLI.start(ARGV)

data/lib/app/controllers/flash.rb

@@ -0,0 +1,90 @@
+require 'json'
+
+class Flash
+  def initialize(req)
+    cookie_hash = req.cookies["_rails_lite_app_flash"]
+    @existing = cookie_hash ? JSON.parse(cookie_hash) : {}
+    @new = {}
+  end
+
+  def [](key)
+    merged = @existing.merge(@new)
+    merged[key.to_s]
+  end
+
+  def []=(key, val)
+    if @add_next
+      @existing[key.to_s] = val
+      @add_next = false
+    else
+      @new[key.to_s] = val
+    end
+  end
+
+  def now
+    @add_next = true
+    self
+  end
+
+  def store_flash(res)
+    out_cookie = @new.to_json
+    res.set_cookie('_rails_lite_app_flash', { path: "/", value: out_cookie })
+  end
+end
+
+
+# class Flash
+#   attr_reader :flashy_cookie
+#
+#   def initialize(req)
+#     cookie_hash = req.cookies["_rails_lite_app_flash"]
+#     existing_cookie = JSON.parse(cookie_hash) if cookie_hash
+#     @flashy_cookie = existing_cookie ? existing_cookie : {}
+#   end
+#
+#   def [](key)
+#     @flashy_cookie[key.to_s]
+#   end
+#
+#   def []=(key, val)
+#     if @add_next
+#       old_keys.add(key.to_s)
+#       @add_next = false
+#     end
+#
+#     @flashy_cookie[key] = val
+#   end
+#
+#   def now
+#     @add_next = true
+#     self
+#   end
+#
+#   def delete_old
+#     old_keys.each do |key|
+#       @flashy_cookie.delete(key)
+#     end
+#
+#     @flashy_cookie.delete(:old)
+#   end
+#
+#   # serialize the hash into json and save in a cookie
+#   # add to the responses cookies
+#   def store_flash(res)
+#     delete_old
+#     old_keys = @flashy_cookie.keys
+#     out_cookie = @flashy_cookie.to_json
+#     res.set_cookie('_rails_lite_app_flash', out_cookie)
+#   end
+#
+#   private
+#   def old_keys
+#     @flashy_cookie[:old] ||= Set.new
+#   end
+#
+#   def old_keys=(key_arr)
+#     old_keys
+#     keys.each { |key| @flash_cookie[:old].add(key) }
+#     old_keys.delete(:old)
+#   end
+# end

data/lib/app/controllers/session.rb

@@ -0,0 +1,27 @@
+require 'json'
+require 'byebug'
+class Session
+  # find the cookie for this app
+  # deserialize the cookie into a hash
+
+  def initialize(req)
+    cookie_hash = req.cookies["_rails_lite_app"]
+    existing_cookie = JSON.parse(cookie_hash) if cookie_hash
+    @cookie = existing_cookie ? existing_cookie : {}
+  end
+
+  def [](key)
+    @cookie[key]
+  end
+
+  def []=(key, val)
+    @cookie[key] = val
+  end
+
+  # serialize the hash into json and save in a cookie
+  # add to the responses cookies
+  def store_session(res)
+    out_cookie = @cookie.to_json
+    res.set_cookie('_rails_lite_app', { path: "/", value: out_cookie })
+  end
+end

data/lib/app/controllers/tcontroller_base.rb

@@ -0,0 +1,91 @@
+require 'active_support'
+require 'active_support/inflector'
+require 'active_support/core_ext'
+require 'erb'
+require_relative './session'
+require_relative './flash'
+
+module TGauge
+  class TControllerBase
+    @@defender = false
+    def self.protect_from_forgery
+      @@defender = true
+    end
+
+    attr_reader :req, :res, :params
+    # Setup the controller
+    def initialize(req, res, route_params = {})
+      @req = req
+      @res = res
+      @params = @req.params.merge(route_params)
+    end
+
+    # Helper method to alias @already_built_response
+    def already_built_response?
+      @rendered
+    end
+
+    # Set the response status code and header
+    def redirect_to(url)
+      @rendered ? raise {'Cannote render twice'} : @rendered = true
+      @res['Location'] = url
+      @res.status = 302
+      @session.store_session(res) if @session
+    end
+
+    # Populate the response with content.
+    # Set the response's content type to the given type.
+    # Raise an error if the developer tries to double render.
+    def render_content(content, content_type)
+      @rendered ? raise {'Cannote render twice'} : @rendered = true
+      @res.write(content)
+      @session.store_session(res) if @session
+      @flash.store_flash(res) if @flash
+      @res['Content-Type'] = content_type
+    end
+
+    # use ERB and binding to evaluate templates
+    # pass the rendered html to render_content
+    def render(template_name)
+      class_name = self.class.to_s.underscore
+      class_name.slice! "_controller"
+      view_path = "app/views/#{class_name}/#{template_name}.html.erb"
+      erb = ERB.new(File.read(view_path)).result(binding)
+      render_content(erb, 'text/html')
+    end
+
+    # method exposing a `Session` object
+    def session
+      @session ||= Session.new(@req)
+    end
+
+    def flash
+      @flash ||= Flash.new(@req)
+    end
+
+    # use this with the router to call action_name (:index, :show, :create...)
+    def invoke_action(name)
+      if @@defender && check_authenticity_token
+        @res.write("ATTACK ATTACK!! RUN AND HIDE!")
+        @res.status = 403
+        @res['Content-Type'] = "text/html"
+      else
+        self.send(name)
+        render(name) unless already_built_response?
+      end
+    end
+
+    def form_authenticity_token
+      flash[:_csurf_master_code] = SecureRandom.urlsafe_base64
+    end
+
+    private
+    def check_authenticity_token
+      !@req.get? && (master_code.nil? || master_code != @req.params["authenticity_token"])
+    end
+
+    def master_code
+      flash[:_csurf_master_code]
+    end
+  end
+end

data/lib/app/models/associatable.rb

@@ -0,0 +1,117 @@
+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 < AssocOptions
+  def initialize(name, options = {})
+    @foreign_key = options[:foreign_key] || (name.to_s.foreign_key).to_sym
+    @primary_key = options[:primary_key] || :id
+    @class_name = options[:class_name] || name.to_s.classify
+  end
+end
+
+class HasManyOptions < AssocOptions
+  def initialize(name, self_class_name, options = {})
+    @foreign_key = options[:foreign_key] || (self_class_name.foreign_key).to_sym
+    @primary_key = options[:primary_key] || :id
+    @class_name = options[:class_name] || name.to_s.singularize.classify
+  end
+end
+
+module Associatable
+  # Phase IIIb
+  def belongs_to(name, options = {})
+    options = BelongsToOptions.new(name, options)
+
+    define_method(name) do
+      fkey_val = self.send(options.foreign_key)
+      class_obj = options.model_class
+
+      class_obj.where(options.primary_key => fkey_val).first
+    end
+
+    assoc_options[name] = options
+  end
+
+  def has_many(name, options = {})
+    # ...
+    unless options.first[0] == :through
+      options = HasManyOptions.new(name, self.to_s, options)
+
+      define_method(name) do
+        class_obj = options.model_class
+        pr_key = self.send(options.primary_key)
+        class_obj.where(options.foreign_key => pr_key)
+      end
+
+      assoc_options[name] = options
+    else
+      options[:source] ||= name
+      through(name, options[:through], options[:source])
+    end
+  end
+
+  def through(name, through_name, source_name)
+    define_method(name) do
+      through_options = self.class.assoc_options[through_name]
+      source_options = through_options.model_class.assoc_options[source_name]
+
+      if through_options.is_a?(BelongsToOptions)
+        # A to B has a belongs_to relationship
+        a_test_key = self.send(through_options.foreign_key)
+        b_column = through_options.primary_key
+      else
+        # A to B has a has_many relationship
+        a_test_key = self.send(through_options.primary_key)
+        b_column = through_options.foreign_key
+      end
+
+      if source_options.is_a?(BelongsToOptions)
+        # B to C has a belongs_to relationship
+        b_test_key = source_options.foreign_key
+        c_column = source_options.primary_key
+      else
+        # B to C has a has_many relationship
+        b_test_key = source_options.primary_key
+        c_column = source_options.foreign_key
+      end
+      source_table = source_options.table_name
+      through_table = through_options.table_name
+
+      all_data = DBConnection.execute(<<-SQL)
+        SELECT
+          #{source_table}.*
+        FROM
+          #{through_table}
+        JOIN
+          #{source_table} ON #{source_table}.#{c_column} = #{through_table}.#{b_test_key}
+        WHERE
+          #{through_table}.#{b_column} = #{a_test_key}
+      SQL
+
+      source_options.model_class.parse_all(all_data)
+    end
+  end
+
+  def has_one (name, options = {})
+    options[:source] ||= name
+    through(name, options[:through], options[:source])
+  end
+
+  def assoc_options
+    @assoc_options ||= {}
+  end
+end

data/lib/app/models/searchable.rb

@@ -0,0 +1,47 @@
+module Searchable
+  def where(params)
+    relation_obj ||= LazyRelation.new(self, self.table_name, {})
+    relation_obj.where(params)
+    relation_obj
+  end
+end
+
+class LazyRelation
+  def initialize(klass, table_name, command_hash)
+    @klass = klass
+    @table_name = table_name
+    @command_hash = command_hash
+  end
+
+  def where(params)
+    @command_hash = params.merge(@command_hash)
+    self
+  end
+
+  def where_str
+    @command_hash.map do |col, val|
+      val = "'#{val}'" if val.is_a?(String)
+      "#{@table_name}.#{col} = #{val}"
+    end.join(" AND ")
+  end
+
+
+  def execute
+    all_attrs = DBConnection.execute(<<-SQL)
+      SELECT
+        #{@table_name}.*
+      FROM
+        #{@table_name}
+      WHERE
+        #{where_str}
+    SQL
+
+    all_attrs.map { |atts| @klass.new(atts) }
+  end
+
+  def method_missing(method_name, *args)
+    obj = execute
+    obj[0].send(method_name, *args)
+  end
+
+end