rails_lite 0.1.0

data/lib/scaffold/lib/controller/controller_callbacks.rb

@@ -0,0 +1,17 @@
+module ControllerCallbacks
+  METHODS = [:index, :create, :new, :edit, :update, :show, :destroy]
+
+  def before_action(method, options = { only: METHODS, except: [] })
+  default = { only: METHODS, except: [] }
+  default.merge!(options)
+
+    names = default[:only] - default[:except]
+    names.each do |name|
+      m = instance_method(name)
+      define_method(name) do
+        
+        m.bind(self).call unless send(method)
+      end
+    end
+  end
+end

data/lib/scaffold/lib/controller/cookies/flash.rb

@@ -0,0 +1,33 @@
+require 'json'
+require_relative 'flash_now'
+
+class Flash
+  attr_reader :now
+
+  def initialize(req)
+    cookie = req.cookies['_rails_lite_app_flash']
+    if cookie
+      @now = FlashNow.new(JSON.parse(cookie))
+    else
+      @now = FlashNow.new
+    end
+    
+    @cookie_data = {}
+  end
+
+  def [](key)
+    now[key.to_s] || cookie_data[key.to_s]
+  end
+
+  def []=(key, val)
+    cookie_data[key.to_s] = val
+  end
+  
+  def store_flash(res)
+    cookie = { path: '/', value: JSON.generate(cookie_data) }
+    res.set_cookie('_rails_lite_app_flash', cookie)
+  end
+
+  private
+  attr_reader :cookie_data
+end

data/lib/scaffold/lib/controller/cookies/flash_now.rb

@@ -0,0 +1,15 @@
+class FlashNow
+  attr_reader :hash
+
+  def initialize(hash = {})
+    @hash = hash
+  end
+
+  def [](key)
+    hash[key.to_s]
+  end
+
+  def []=(key, val)
+    hash[key.to_s] = val
+  end
+end

data/lib/scaffold/lib/controller/cookies/session.rb

@@ -0,0 +1,29 @@
+require 'json'
+
+class Session
+
+  def initialize(req)
+    cookie = req.cookies['_rails_lite_app']
+    if cookie
+      @cookie_data = JSON.parse(cookie)
+    else
+      @cookie_data = {}
+    end
+  end
+
+  def [](key)
+    cookie_data[key.to_s]
+  end
+
+  def []=(key, val)
+    cookie_data[key.to_s] = val
+  end
+
+  def store_session(res)
+    cookie = { path: '/', value: JSON.generate(cookie_data) }
+    res.set_cookie('_rails_lite_app', cookie)
+  end
+
+  private
+  attr_reader :cookie_data
+end

data/lib/scaffold/lib/controller/strong_params.rb

@@ -0,0 +1,40 @@
+class StrongParams
+  attr_reader :params
+  
+  def self.to_sym(hash)
+    sym_hash = {}
+    hash.each do |key, val|
+      sym_hash[key.to_sym] = (val.is_a?(Hash) ? to_sym(val) : val)
+    end
+
+    sym_hash
+  end
+
+  def self.new_syms(params)
+    StrongParams.new(StrongParams.to_sym(params))
+  end
+
+  def initialize(params)
+    @params = params
+  end
+  
+  def require(class_name)
+    StrongParams.new(params[class_name])
+  end
+
+  def permit(*keys)
+    permited_params = {}
+    keys.each { |key| permited_params[key] = params[key] }
+    permited_params
+  end
+
+  def [](key)
+    params[key.to_sym]
+  end
+
+  private
+
+  def []=(key, val)
+    params[key.to_sym] = val
+  end
+end

data/lib/scaffold/lib/middleware/file_server.rb

@@ -0,0 +1,42 @@
+class FileServer
+
+  MIME_TYPES = {
+    '.txt' => 'text/plain',
+    '.jpg' => 'image/jpeg',
+    '.zip' => 'application/zip'
+  }
+
+  def initialize(root)
+    @root = root
+  end
+
+  def call(env)
+    res = Rack::Response.new
+    file_name = requested_file_name(env)
+
+    if File.exist?(file_name)
+      serve_file(file_name, res)
+    else
+      res.status = 404
+      res.write("File not found")
+    end
+    res
+  end
+
+  private
+
+  def serve_file(file_name, res)
+    extension = File.extname(file_name)
+    content_type = MIME_TYPES[extension]
+    file = File.read(file_name)
+    res["Content-type"] = content_type
+    res.write(file)
+  end
+
+  def requested_file_name(env)
+    req = Rack::Request.new(env)
+    path = req.path
+    dir = File.dirname(__FILE__)
+    File.join(dir, '..', '..', path)
+  end
+end

data/lib/scaffold/lib/middleware/show_exceptions.rb

@@ -0,0 +1,62 @@
+require 'erb'
+
+class ShowExceptions
+  attr_reader :app
+
+  def initialize(app)
+    @app = app
+  end
+
+  def call(env)
+    app.call(env)
+  rescue Exception => e
+    render_exception(e)
+  end
+
+  private
+
+  def render_exception(e)
+    dir_path = File.dirname(__FILE__)
+    template_fname = File.join(dir_path, "templates", "rescue.html.erb")
+    template = File.read(template_fname)
+    body = ERB.new(template).result(binding)
+
+    ['500', {'Content-type' => 'text/html'}, [body]]
+  end
+
+  def error_source_file(e)
+    # stack_trace_top = e.backtrace.first.split(':')
+    stack_trace_top(e)[0]
+  end
+
+  def stack_trace_top(e)
+    e.backtrace.first.split(':')
+  end
+
+  def extract_formatted_source(e)
+    source_file_name = error_source_file(e)
+    source_line_num = source_line_num(e)
+    source_lines = extract_source(source_file_name)
+    format_source(source_lines, source_line_num)
+  end
+
+  def source_line_num(e)
+    stack_trace_top(e)[1].to_i
+  end
+
+  def formatted_source(file, source_line_num)
+    source_lines = extract_source(file)
+    format_source(source_lines, source_line_num)
+  end
+
+  def extract_source(file)
+    source_file = File.open(file, 'r')
+    source_file.readlines
+  end
+
+  def format_source(source_lines, source_line_num)
+    start = [0, source_line_num - 3].max
+    lines = source_lines[start..(start + 5)]
+    Hash[*(start+1..(lines.count + start)).zip(lines).flatten]
+  end
+end

data/lib/scaffold/lib/middleware/static.rb

@@ -0,0 +1,31 @@
+require_relative 'file_server'
+
+class Static
+  attr_reader :app, :root, :file_server
+  
+  def initialize(app)
+    @app = app
+    @root = :public
+    @file_server = FileServer.new(root)
+  end
+
+  def call(env)
+    req = Rack::Request.new(env)
+    path = req.path
+
+    if can_serve?(path)
+      res = file_server.call(env)
+    else
+      res = app.call(env)
+    end
+
+    res
+  end
+
+  private
+
+  def can_serve?(path)
+    path.index("/#{root}")
+  end
+end
+

data/lib/scaffold/lib/middleware/templates/rescue.html.erb

@@ -0,0 +1,49 @@
+<head>
+  <style>
+    .header {
+      background: red;
+    }
+    .source-view {
+      border: 10px solid lightgray;
+      width: 800px;
+    }
+    .line {
+      white-space: pre-wrap;
+    }
+    .line-num {
+      background: lightgray
+    }
+    .line.error {
+      background: red;
+    }
+  </style>
+</head>
+
+<body>
+  <h2 class='header'><%=e.class%>: <%=e.message%></h2>
+
+  <h4>Extracted source (around line <b><%=source_line_num(e)%></b>):</h4>
+
+  <div class='source-view'>
+    <table cellpadding="0" cellspacing="0">
+      <% extract_formatted_source(e).each do |line_num, line| %>
+        <tr>
+          <td>
+            <pre class='line-num'><%=line_num %></pre>
+          </td>
+          <td>
+            <pre class='line
+              <%= 'error' if line_num == source_line_num(e)%>'><%= line %></pre>
+          </td>
+        </tr>
+      <% end %>
+    </table>
+  </div>
+  <h5><%= File.expand_path(error_source_file(e)) %></h5>
+
+  <h3>Stack trace</h3>
+  <% e.backtrace.each do |stack_line| %>
+    <%= stack_line %>
+    <br>
+  <% end %>
+</body>

data/lib/scaffold/lib/model/associations/assoc_options.rb

@@ -0,0 +1,16 @@
+class AssocOptions
+  attr_accessor(
+    :foreign_key,
+    :class_name,
+    :primary_key,
+    :optional
+  )
+
+  def model_class
+    class_name.to_s.constantize
+  end
+
+  def table_name
+    model_class.table_name
+  end
+end

data/lib/scaffold/lib/model/associations/associatable.rb

@@ -0,0 +1,120 @@
+require_relative 'has_many_options'
+require_relative 'belongs_to_options'
+
+module Associatable
+
+  def belongs_to(name, options = {})
+    options = BelongsToOptions.new(name, options)
+    assoc_options[name] = options
+
+    self.define_method(name) do
+      validations = self.class.validators
+        .map { |validator| [validator.attribute, validator.options[:presence]] }
+
+      unless options.optional || validations.include?([options.foreign_key, true])
+        self.class.validates options.foreign_key, presence: true 
+      end
+      
+      options.model_class.find(self.send(options.foreign_key))
+    end
+  end
+
+  def has_many(name, options = {})
+    if options[:through] && options[:source]
+      has_many_through(name, options[:through], options[:source])
+    else
+      options = HasManyOptions.new(name, self.name, options)
+      assoc_options[name] = options
+    
+      self.define_method(name) do 
+        options.model_class.where(options.foreign_key => self.send(options.primary_key)).parsed_query
+      end
+    end
+  end
+
+  def assoc_options
+    @assoc_options ||= {}
+    @assoc_options
+  end
+
+  def has_one(name, options)
+    through_name = options[:through]
+    source_name = options[:source]
+
+    define_method(name) do
+      through_options = self.class.assoc_options[through_name]
+      source_options = through_options.model_class.assoc_options[source_name]
+
+      through_table = through_options.table_name
+      through_pk = through_options.primary_key
+      through_fk = through_options.foreign_key
+
+      source_table = source_options.table_name
+      source_pk = source_options.primary_key
+      source_fk = source_options.foreign_key
+
+      key_val = self.send(through_fk)
+      results = DBConnection.execute(<<-SQL, key_val)
+        SELECT
+          #{source_table}.*
+        FROM
+          #{through_table}
+        JOIN
+          #{source_table}
+        ON
+          #{through_table}.#{source_fk} = #{source_table}.#{source_pk}
+        WHERE
+          #{through_table}.#{through_pk} = ?
+      SQL
+
+      source_options.model_class.parse_all(results).first
+    end
+  end
+
+  def has_many_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)
+        through_self_id = through_options.primary_key
+        self_through_id = through_options.foreign_key
+      else
+        through_self_id = through_options.foreign_key
+        self_through_id = through_options.primary_key
+      end
+
+      if source_options.is_a?(BelongsToOptions)
+        through_source_id = source_options.foreign_key
+        source_through_id = source_options.primary_key
+      else
+        through_source_id = source_options.primary_key
+        source_through_id = source_options.foreign_key
+      end
+
+      through_table = through_options.table_name
+      source_table = source_options.table_name
+
+      key_val = self.send(:id)
+      results = DBConnection.execute(<<-SQL, key_val)
+        SELECT
+          #{source_table}.*
+        FROM
+          #{through_table}
+        JOIN
+          #{source_table}
+        ON
+          #{through_table}.#{through_source_id} = #{source_table}.#{source_through_id}
+        JOIN
+          #{self.class.table_name}
+        ON
+          #{self.class.table_name}.#{self_through_id} = #{through_table}.#{through_self_id}
+        WHERE
+          #{self.class.table_name}.id = ?
+      SQL
+
+      source_options.model_class.parse_all(results)
+    end
+  end
+
+end