rails_lite 0.1.0

data/lib/scaffold/lib/model/relations/searchable.rb

@@ -0,0 +1,27 @@
+module Searchable
+  
+  def where(params)
+    relation = Relation.new(table_name: self.table_name)
+    relation.where(params)
+  end
+
+  def joins(table_name)
+    relation = Relation.new(table_name: self.table_name)
+    relation.joins(table_name)
+  end
+
+  def left_joins(table_name)
+    relation = Relation.new(table_name: self.table_name)
+    relation.left_joins(table_name)
+  end
+
+  def select(*params)
+    relation = Relation.new(table_name: self.table_name)
+    relation.select(*params)
+  end
+
+  def find_by(params)
+    arr = where(params)
+    arr.empty? ? nil : arr.first
+  end
+end

data/lib/scaffold/lib/model/validations/validations.rb

@@ -0,0 +1,31 @@
+require 'active_support/concern'
+require_relative 'validator'
+
+module Validations
+  extend ActiveSupport::Concern
+
+  def valid?
+    before_valid
+    self.class.validators.all? { |validator| validator.valid?(self) }
+  end
+
+  def errors
+    errors_array = []
+    self.class.validators.each do |validator|
+      errors_array += validator.errors(self)
+    end
+    
+    errors_array
+  end
+
+  module ClassMethods
+  
+    def validators
+      @validators ||= []
+    end
+    
+    def validates(attribute, options = {})
+      validators << Validator.new(attribute, options)
+    end
+  end
+end

data/lib/scaffold/lib/model/validations/validator.rb

@@ -0,0 +1,81 @@
+class Validator
+  attr_reader :options, :attribute
+
+  def initialize(attribute, options = {})
+    default = {
+      allow_nil: false,
+      presence: false,
+      uniqueness: false,
+      length: false,
+      class: false
+    }
+
+    default.merge!(options)
+    @attribute = attribute
+    @options = default
+  end
+
+  def allow_nil(_obj, _val, _errors_array)
+  end
+
+  def presence(_obj, val, errors_array)
+    errors_array << "#{attribute} must be present" if val.blank?
+  end
+
+  def uniqueness(obj, val, errors_array)
+    if obj.id.nil?
+      where_line = "#{attribute} = '#{val}'"
+    else
+      where_line = "#{attribute} = '#{val}' AND id != #{obj.id}"
+    end
+    
+    arr = obj.class.where(where_line)
+    errors_array << "#{attribute} must be unique" unless arr.empty?
+  end
+
+  def class(_obj, val, errors_array)
+    errors_array << "#{attribute} must be #{options[:class]}" unless val.is_a?(options[:class])
+  end
+
+  def length(_obj, val, errors_array)
+    if val.nil?
+      errors_array << "#{attribute} can't be nil" unless options[:length][:allow_nil]
+
+      return errors_array
+    elsif options[:length].is_a?(Hash)
+
+      min = options[:length][:minimum]
+      if min && val.length < min
+        errors_array << "#{attribute} must be longer than #{min} characters"
+      end
+      
+      max = options[:length][:maximum]
+      if max && val.length > max
+        errors_array << "#{attribute} must be shorter than #{max} characters"
+      end
+    else
+      unless val.length = options[:length]
+        errors_array << "#{attribute} must be #{max} characters"
+      end
+    end
+
+    errors_array
+  end
+
+  def valid?(obj)
+    errors(obj).empty?
+  end
+
+  def errors(obj)
+    errors_array = []
+    val = obj.send(attribute)
+
+    return errors_array if val.nil? && options[:allow_nil]
+
+    options.each do |name, validate|
+      self.send(name, obj, val, errors_array) if validate
+    end
+
+    errors_array
+  end
+end

data/lib/scaffold/lib/router/route.rb

@@ -0,0 +1,24 @@
+class Route
+  attr_reader :pattern, :http_method, :controller_class, :action_name
+
+  def initialize(pattern, http_method, controller_class, action_name)
+    @pattern, @http_method, @controller_class, @action_name = pattern, http_method, controller_class, action_name
+  end
+
+  def matches?(req)
+    method = req.params['_method'] || req.request_method
+    pattern =~ req.path && http_method.to_s == method.downcase
+  end
+
+  def run(req, res, patterns)
+    route_params = {}
+    match_data = pattern.match(req.path)
+    
+    match_data.names.each do |key|
+      route_params[key] = match_data[key]
+    end
+    
+    controller = controller_class.new(req, res, route_params, patterns)
+    controller.invoke_action(action_name)
+  end
+end

data/lib/scaffold/lib/router/router.rb

@@ -0,0 +1,192 @@
+require_relative 'route'
+require_relative '../utils/url_helpers'
+
+class Router
+  include UrlHelpers
+  attr_reader :routes, :patterns
+
+  def initialize
+    @routes = []
+    @patterns = []
+    @current_route = "^/"
+    @member_route = "^/"
+    @collection_route = "^/"
+    @nested_route = "^/"
+    @current_class = nil;
+  end
+
+  def display_routes
+    routes.each do |route|
+      url = Router.make_url(route.pattern)
+      method = route.http_method
+      controller = route.controller_class
+      helper = Router.make_helper_name(route.pattern)
+      action = route.action_name
+
+      puts "#{method.to_s.upcase}: #{url}, #{controller}##{action}, #{helper}"
+    end
+  end
+
+  def add_route(pattern, method, controller_class, action_name)
+    routes << Route.new(pattern, method, controller_class, action_name)
+    patterns << pattern unless patterns.include?(pattern)
+  end
+
+  def draw(&proc)
+    self.instance_eval(&proc)
+  end
+
+  [:get, :post, :patch, :delete, :put].each do |http_method|
+    define_method(http_method) do |name, options = {}|
+      default = { to: "#{current_class}##{name}" }
+      default.merge!(options)
+
+      if name.is_a?(Symbol)
+        pattern = Regexp.new("#{current_route}#{name}/?$")
+      elsif name.is_a?(String)
+        url_arr = Router.make_url_arr_from_path(name)
+        url_arr.map! do |str|
+          if str[0] === ":"
+            "(?<#{str[1..-1]}>\\d+)"
+          else
+            str
+          end
+        end
+
+        path = url_arr.join("/")
+        pattern = Regexp.new("^/#{path}/?$")
+      end
+      
+      to_array = default[:to].split('#')
+      controller_class = "#{to_array[0].capitalize}Controller".constantize
+      action_name = to_array[1].to_sym
+      add_route(pattern, http_method, controller_class, action_name)
+    end
+  end
+
+  def match(req)
+    routes.find { |route| route.matches?(req) }
+  end
+
+  def resources(name, options = {}, &prc)
+    controller_class = "#{name.capitalize}Controller".constantize
+    methods = [:index, :create, :new, :edit, :update, :show, :destroy]
+    patterns = {
+      index: [Regexp.new("#{current_route}#{name}/?$"), :get],
+      new: [Regexp.new("#{current_route}#{name}/new/?$"), :get],
+      show: [Regexp.new("#{current_route}#{name}/(?<id>\\d+)/?$"), :get],
+      create: [Regexp.new("#{current_route}#{name}$"), :post],
+      destroy: [Regexp.new("#{current_route}#{name}/(?<id>\\d+)/?$"), :delete],
+      update: [Regexp.new("#{current_route}#{name}/(?<id>\\d+)/?$"), :patch],
+      edit: [Regexp.new("#{current_route}#{name}/(?<id>\\d+)/edit/?$"), :get]
+    }
+    
+    default = { only: methods, except: [] }
+    default.merge!(options)
+    names = default[:only] - default[:except]
+
+    names.each do |name|
+      params = patterns[name] + [controller_class] + [name]
+      add_route(*params)
+    end
+
+    self.current_class = name
+    set_resources_routes(name)
+    prc.call if prc
+    reset_routes
+
+    nil
+  end
+
+  def resource(name, options = {}, &prc)
+    controller_class = "#{name.capitalize}Controller".constantize
+    methods = [:index, :create, :new, :edit, :update, :show, :destroy]
+    patterns = {
+      index: [Regexp.new("#{current_route}#{name}/?$"), :get],
+      new: [Regexp.new("#{current_route}#{name}/new/?$"), :get],
+      show: [Regexp.new("#{current_route}#{name}/?$"), :get],
+      create: [Regexp.new("#{current_route}#{name}$"), :post],
+      destroy: [Regexp.new("#{current_route}#{name}/?$"), :delete],
+      update: [Regexp.new("#{current_route}#{name}/?$"), :patch],
+      edit: [Regexp.new("#{current_route}#{name}/edit/?$"), :get]
+    }
+    
+    default = { only: methods, except: [] }
+    default.merge!(options)
+    names = default[:only] - default[:except]
+
+    names.each do |name|
+      params = patterns[name] + [controller_class] + [name]
+      add_route(*params)
+    end
+
+    self.current_class = name
+    set_resource_routes(name)
+    prc.call if prc
+    reset_routes
+
+    nil
+  end
+
+  def member(&prc)
+    self.current_route = member_route
+    prc.call if prc
+    self.current_route = nested_route
+
+    nil
+  end
+
+  def collection(&prc)
+    self.current_route = collection_route
+    prc.call if prc
+    self.current_route = nested_route
+
+    nil
+  end
+
+  def root(options = {})
+    to_array = options[:to].split('#')
+    pattern = Regexp.new("^/?$")
+    http_method = :get
+    controller_class = "#{to_array[0].capitalize}Controller".constantize
+    action_name = to_array[1].to_sym
+
+    add_route(pattern, http_method, controller_class, action_name)
+  end
+
+  def run(req, res)
+    route = match(req)
+    if route
+      route.run(req, res, patterns)
+    else
+      res.status = 404
+      res.write('Route not found')
+    end
+  end
+
+  private 
+  attr_accessor :current_route, :member_route, :collection_route,
+    :nested_route, :current_class
+
+  def set_resources_routes(name)
+    self.member_route = current_route +  "#{name}/(?<id>\\d+)/"
+    self.collection_route = current_route +  "#{name}/"
+    self.nested_route = current_route + "#{name}/(?<#{name.to_s.singularize}_id>\\d+)/"
+    self.current_route = nested_route
+  end
+
+  def set_resource_routes(name)
+    self.member_route = current_route +  "#{name}/"
+    self.collection_route = current_route +  "#{name}/"
+    self.nested_route = current_route +  "#{name}/"
+    self.current_route = nested_route
+  end
+
+  def reset_routes
+    self.current_route = "^/"
+    self.member_route = "^/"
+    self.collection_route = "^/"
+    self.nested_route = "^/"
+    self.current_class = nil
+  end
+end

data/lib/scaffold/lib/utils/url_helpers.rb

@@ -0,0 +1,96 @@
+require 'active_support/concern'
+
+module UrlHelpers
+  extend ActiveSupport::Concern
+
+  module ClassMethods
+
+    def make_url_arr(pattern)
+      pattern.inspect.delete('\^$?<>/+()')
+          .split('\\').drop(1).reject { |el| el == "d"}
+    end
+
+    def make_url_arr_from_path(path)
+      path.split("/").drop(1)
+    end
+
+    def make_url(pattern)
+      "/" + make_url_arr(pattern).join("/")
+    end
+
+    def make_helpers(patterns)
+      patterns.each do |pattern|
+        url_arr = make_url_arr(pattern)
+        if url_arr.include?("id") ||  url_arr.any? { |str| str.include?("_id") }
+          make_id_helpers(url_arr)
+        else
+          make_idless_helpers(url_arr)
+        end
+      end
+    end
+
+    def make_helper_name(pattern)
+      url_arr = make_url_arr(pattern)
+      return "root_url" if url_arr.empty?
+
+      if url_arr.include?("id") ||  url_arr.any? { |str| str.include?("_id") }
+        make_id_helper_name(url_arr)
+      else
+        make_idless_helper_name(url_arr)
+      end
+    end
+    
+    def make_id_helper_name(url_arr)
+      name_arr = url_arr.dup
+      name_arr[0] = url_arr.first.singularize
+      filtered_arr = name_arr.reject do |el| 
+        el == "id" || el.include?("_id")
+      end
+
+      if filtered_arr.last == "edit" || filtered_arr.last == "new"
+        filtered_arr.unshift(filtered_arr.pop) 
+      end
+
+      filtered_arr.join("_") + "_url"
+    end
+
+    def make_idless_helper_name(url_arr)
+      url_arr = url_arr.dup
+       if url_arr.last == "edit" || url_arr.last == "new"
+        url_arr.unshift(url_arr.pop) 
+      end
+
+      url_arr.join("_") + "_url"
+    end
+
+    private
+
+    def make_idless_helpers(url_arr)
+      helper_name = make_idless_helper_name(url_arr)
+      url = "/" + url_arr.join("/")
+
+      define_method(helper_name) do
+        url
+      end
+    end
+
+    def make_id_helpers(url_arr)
+      helper_name = make_id_helper_name(url_arr)
+      
+      define_method(helper_name) do |*ids|
+        url = url_arr.map do |el|
+          if el == "id" || el.include?("_id")
+            id = ids.pop
+            obj_id = id.try(:id)
+
+            "#{obj_id || id}"
+          else
+            el
+          end
+        end
+          
+        "/" + url.join("/")
+      end
+    end
+  end
+end