reloj 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ee697fff25d8314ec1c3fd14e7316e34ffdd6e37
+  data.tar.gz: 9e0129f049be415f577a1f66a6bc55c18c9609fc
+SHA512:
+  metadata.gz: 2d0a1fa8bffc06eb067d4fe9ebea366dbda41bfa50f367f62e9ba4b78af992279887c5787e8c956600c765a6cb33e4b7626e4e7b7eead06f08fd7cb1087fefef
+  data.tar.gz: f1d90f2e54f1e42d6337ccc7a780e130da1e161c2aab0ef109b5d4d10726a5a7f2b85b6d5c93325d58bf37db90ed63a049b087b42b46e6257a60f82ebe944d62

data/.rspec

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

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,64 @@
+PATH
+  remote: .
+  specs:
+    reloj (0.1.0)
+      activesupport (~> 4.2)
+      pg (~> 0.18)
+      require_all (~> 1.3)
+      webrick (~> 1.3)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (4.2.4)
+      i18n (~> 0.7)
+      json (~> 1.7, >= 1.7.7)
+      minitest (~> 5.1)
+      thread_safe (~> 0.3, >= 0.3.4)
+      tzinfo (~> 1.1)
+    byebug (6.0.2)
+    coderay (1.1.0)
+    diff-lcs (1.2.5)
+    i18n (0.7.0)
+    json (1.8.3)
+    method_source (0.8.2)
+    minitest (5.8.1)
+    pg (0.18.3)
+    pry (0.10.1)
+      coderay (~> 1.1.0)
+      method_source (~> 0.8.1)
+      slop (~> 3.4)
+    rake (10.4.2)
+    require_all (1.3.2)
+    rspec (3.3.0)
+      rspec-core (~> 3.3.0)
+      rspec-expectations (~> 3.3.0)
+      rspec-mocks (~> 3.3.0)
+    rspec-core (3.3.2)
+      rspec-support (~> 3.3.0)
+    rspec-expectations (3.3.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.3.0)
+    rspec-mocks (3.3.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.3.0)
+    rspec-support (3.3.0)
+    slop (3.6.0)
+    thread_safe (0.3.5)
+    tzinfo (1.2.2)
+      thread_safe (~> 0.1)
+    webrick (1.3.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.10)
+  byebug (~> 6.0)
+  pry (~> 0.10)
+  rake (~> 10.0)
+  reloj!
+  rspec (~> 3.3)
+
+BUNDLED WITH
+   1.10.6

data/README.md

@@ -0,0 +1,89 @@
+# Reloj
+A lightweight web framework for Ruby for creating database-backed web applications with the Model-View-Controller pattern.
+
+## Getting Started
+
+1. Install Reloj at the command prompt if you haven't yet:
+
+        gem install reloj
+
+2. At the command prompt, create a new Reloj application:
+
+        reloj new myapp
+
+   where "myapp" is the application name.
+
+3. Change directory to `myapp` and start the web server:
+
+        cd myapp
+        reloj server
+
+
+4. Using a browser, go to `http://localhost:3000` and you'll see:
+"Welcome to Reloj!"
+
+## Models and ORM
+Reloj uses the active record pattern for its object-relational mapping.
+To use this functionality in your app, create a class for your model in `app/models` and have the model inherit from ModelBase
+```ruby
+class Cat < ModelBase
+	# custom code goes here
+	
+	finalize!
+end
+```
+###Some commands:
+
+```ruby
+Cat.all
+```
+* Returns an array with instances of class Cat, one instance for each row in table cats
+
+```ruby
+Cat.find(2)
+```
+* Finds the record in table cats with id 2, returns instance of Cat corresponding to that record
+
+## Controllers
+Create controllers in `app/controllers`. Controllers should inherit from `ControllerBase`.
+
+```ruby
+class CatsController < ControllerBase
+
+	def index
+		@cats = Cat.all
+		render :index
+	end
+	
+end
+```
+
+## Routes
+Write your routes in `config/routes.rb`
+
+```ruby
+module App
+  ROUTES = Proc.new do
+    get '/cats', CatsController, :index
+    get '/cats/new', CatsController, :new
+    post '/cats', CatsController, :create
+  end
+end
+```
+
+## Running the sample app
+Reloj includes a generator for a sample app. To check it out:  
+
+1. Generate the sample app
+
+		reloj generate:sample
+
+2. Move into the sample app directory
+
+		cd reloj_sample
+
+3. Run the server
+
+		reloj server
+
+4. Navigate to localhost:3000

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/reloj

@@ -0,0 +1,66 @@
+#!/usr/bin/env ruby
+
+require 'reloj'
+
+class TaskHandler
+
+  def self.run_server
+    require 'require_all'
+    require_all "#{Dir.pwd}/app/**/*.rb"
+    require_relative "#{Dir.pwd}/config/routes.rb"
+
+    router = Reloj::Router.new
+    router.draw(&App::ROUTES)
+
+    server = WEBrick::HTTPServer.new(Port: 3000)
+    server.mount_proc('/') { |req, res| router.run(req, res) }
+    trap('INT') { server.shutdown }
+    server.start
+  end
+
+  def self.generate_project(src, name)
+    # copy skeleton
+    copy_directory(src, name)
+
+    # copy Rakefile and Gemfile
+    copy_directory("common_files/.", name)
+
+    # write db.yml
+    config = { dbname: name }
+    File.write(File.join(Dir.pwd, "#{name}/config/db.yml"), YAML.dump(config))
+  end
+
+  def self.copy_directory(src, dest)
+    FileUtils.cp_r(File.join(skels_dir, src), "./#{dest}")
+  end
+
+  def self.skels_dir
+    @skels_dir ||= File.expand_path(
+      File.dirname(__FILE__) +
+      '/../lib/reloj/skeletons'
+    )
+  end
+end
+
+case ARGV[0]
+when "server"
+  TaskHandler.run_server
+when "new"
+  name = ARGV[1].nil? ? "reloj_app" : ARGV[1]
+  TaskHandler.generate_project('new_app', name)
+when "db"
+  case ARGV[1]
+  when "create"
+    Database.create
+  when "delete"
+    Database.delete
+  when "setup"
+    Database.setup
+  when "reset"
+    Database.reset
+  end
+when "generate:sample"
+  TaskHandler.generate_project('sample_app', 'reloj_sample')
+else
+  puts "Invalid reloj command"
+end

data/lib/reloj/core/controller_base.rb

@@ -0,0 +1,68 @@
+require 'active_support'
+require 'active_support/core_ext'
+require 'active_support/inflector'
+require 'erb'
+require_relative './session'
+require_relative './params'
+require_relative './flash'
+require_relative './route_helper'
+
+
+module Reloj
+  class ControllerBase
+    include RouteHelper
+    attr_reader :params, :req, :res
+
+    def initialize(req, res, route_params = {}, paths = [])
+      @req = req
+      @res = res
+      @already_built_response = false
+      @params = Params.new(req, route_params)
+      @paths = paths
+      self.class.create_helper_methods(paths)
+    end
+
+    def already_built_response?
+      @already_built_response
+    end
+
+    def redirect_to(url)
+      raise if already_built_response?
+      @res.status = 302
+      @res["Location"] = url
+      @already_built_response = true
+      flash.store_flash(@res)
+      session.store_session(@res)
+    end
+
+    def render_content(content, content_type)
+      raise if already_built_response?
+      @already_built_response = true
+      @res.content_type = content_type
+      @res.body = content
+      flash.store_flash(@res)
+      session.store_session(@res)
+    end
+
+    def render(template_name)
+      controller_name = self.class.to_s.underscore
+      f = File.read("app/views/#{controller_name}/#{template_name}.html.erb")
+      f = ERB.new(f)
+      render_content(f.result(binding), "text/html")
+    end
+
+    def session
+      @session ||= Session.new(@req)
+    end
+
+    def flash
+      @flash ||= Flash.new(@req)
+    end
+
+    def invoke_action(name)
+      self.send(name)
+      render(name) unless self.already_built_response?
+    end
+
+  end
+end

data/lib/reloj/core/flash.rb

@@ -0,0 +1,38 @@
+require 'json'
+require 'webrick'
+
+module Reloj
+  class Flash
+    # find the cookie for this app
+    # deserialize the cookie into a hash
+    def initialize(req)
+      req.cookies.each do |cookie|
+        if cookie.name == '_flash'
+          @_old_flash = JSON.parse(cookie.value)
+        end
+      end
+      @_old_flash ||= {}
+      @_new_flash ||= {}
+    end
+
+    def [](key)
+      @_old_flash[key] || @_new_flash[key]
+    end
+
+    def []=(key, val)
+      @_new_flash[key] = val
+    end
+
+    def now
+      @_old_flash
+    end
+
+    # serialize the hash into json and save in a cookie
+    # add to the responses cookies
+    def store_flash(res)
+      cookie = WEBrick::Cookie.new('_flash', @_new_flash.to_json)
+      cookie.path = '/'
+      res.cookies << cookie
+    end
+  end
+end

data/lib/reloj/core/params.rb

@@ -0,0 +1,52 @@
+require 'uri'
+
+module Reloj
+  class Params
+    def initialize(req, route_params = {})
+      @params = route_params
+      if req.query_string
+        @params.merge!(parse_www_encoded_form(req.query_string))
+      end
+      @params.merge!(parse_www_encoded_form(req.body)) if req.body
+    end
+
+    def [](key)
+      key = key.to_s
+      @params[key]
+    end
+
+    def to_s
+      @params.to_json.to_s
+    end
+
+    class AttributeNotFoundError < ArgumentError; end;
+
+    private
+    # this should return deeply nested hash, ex:
+    # user[address][street]=main&user[address][zip]=89436
+    # should return
+    # { "user" => { "address" => { "street" => "main", "zip" => "89436" } } }
+    def parse_www_encoded_form(www_encoded_form)
+      x = URI::decode_www_form(www_encoded_form)
+      result = {}
+      x.each do |arr|
+        parsed_keys = parse_key(arr.first)
+        value = arr.last
+        location_in_result = result
+        parsed_keys.each_with_index do |parsed_key, i|
+          location_in_result[parsed_key] = value if i == parsed_keys.length - 1
+          location_in_result[parsed_key] ||= {}
+          location_in_result = location_in_result[parsed_key]
+        end
+      end
+
+      result
+    end
+
+    # this should return an array
+    # user[address][street] should return ['user', 'address', 'street']
+    def parse_key(key)
+      key.split(/\]\[|\[|\]/)
+    end
+  end
+end

data/lib/reloj/core/route_helper.rb

@@ -0,0 +1,45 @@
+module RouteHelper
+
+  def RouteHelper.included(klass)
+    klass.extend ClassMethods
+  end
+
+  #maybe add link_to and button_to here
+
+  module ClassMethods
+
+    def create_helper_methods(paths)
+      paths.each do |path|
+        create_helper_method(path)
+      end
+    end
+
+    def create_helper_method(path)
+      nouns = path.split('/')
+      nouns.delete("")
+      if nouns.any? { |noun| noun[0] == ":" }
+        build_nested_route_helper(nouns)
+      else
+        method_name = nouns.join("_") + "_path"
+        define_method(method_name) { path }
+      end
+    end
+
+    def build_nested_route_helper(nouns)
+      just_names = nouns.select { |noun| noun[0] != ":" }
+      method_name = nouns.select do |noun|
+        noun[0] != ":"
+      end.join("_") + "_path"
+
+      define_method(method_name) do |*ids|
+        result = []
+        just_names.each do |noun|
+          result << noun
+          result << ids.shift unless ids.empty?
+        end
+        result.join('/')
+      end
+    end
+  end
+
+end

data/lib/reloj/core/router.rb

@@ -0,0 +1,89 @@
+require_relative './route_helper'
+
+
+module Reloj
+  class Route
+    attr_reader :pattern, :http_method, :controller_class, :action_name
+
+    def initialize(pattern, http_method, controller_class, action_name)
+      @pattern = pattern
+      @http_method = http_method
+      @controller_class = controller_class
+      @action_name = action_name
+      # save all helpers in the routes
+    end
+
+
+    def matches?(req)
+      req.request_method.downcase.to_sym == @http_method &&
+      @pattern.match(req.path)
+    end
+
+
+    def run(req, res, paths = [])
+      route_params = {}
+      matches = @pattern.match(req.path)
+      matches.names.each do |key|
+        route_params[key] = matches[key]
+      end
+      #pass the methods to the controller class here
+      @controller_class.new(req, res, route_params, paths).invoke_action(@action_name)
+    end
+  end
+
+  class Router
+    attr_reader :routes, :helpers
+
+    def self.regex_from_pattern_string(pattern_string)
+      x = pattern_string.split('/').map do |part|
+        part.gsub(/:(.+)[\/]{,1}/, '(?<\1>\d+)')
+      end.join('/')
+
+      Regexp.new("^#{x}\/?$")
+    end
+
+    def initialize
+      @routes = []
+      @paths = []
+    end
+
+    def add_helper_attributes(pattern, action_name)
+      #need controller name
+      # will get that when passed to controller
+      #need action
+      @paths <<  pattern
+    end
+
+    # simply adds a new route to the list of routes
+    def add_route(pattern, method, controller_class, action_name)
+      parsed_pattern = Router.regex_from_pattern_string(pattern.to_s)
+      route = Route.new(parsed_pattern, method, controller_class, action_name)
+      @routes << route
+      add_helper_attributes(pattern, action_name)
+    end
+
+    def draw(&proc)
+      instance_eval(&proc)
+    end
+
+    [:get, :post, :put, :delete].each do |http_method|
+      define_method(http_method) do |pattern, controller_class, action_name|
+        add_route(pattern, http_method, controller_class, action_name)
+      end
+    end
+
+    def match(req)
+      @routes.each { |route| return route if route.matches?(req) }
+      nil
+    end
+
+    def run(req, res)
+      if match(req)
+        #pass in the helper_attributes here
+        match(req).run(req, res, @paths)
+      else
+        res.status = 404
+      end
+    end
+  end
+end

data/lib/reloj/core/session.rb

@@ -0,0 +1,32 @@
+require 'json'
+require 'webrick'
+
+module Reloj
+  class Session
+    # find the cookie for this app, deserialize into hash
+    def initialize(req)
+      req.cookies.each do |cookie|
+        if cookie.name == '_rails_lite_app'
+          @_rails_lite_app = JSON.parse(cookie.value)
+        end
+      end
+      @_rails_lite_app ||= {}
+    end
+
+    # convenience methods
+    def [](key)
+      @_rails_lite_app[key]
+    end
+
+    def []=(key, val)
+      @_rails_lite_app[key] = val
+    end
+
+    # serialize the hash into json and save in a cookie, add to responses
+    def store_session(res)
+      cookie = WEBrick::Cookie.new('_rails_lite_app', @_rails_lite_app.to_json)
+      cookie.path = '/'
+      res.cookies << cookie
+    end
+  end
+end

data/lib/reloj/orm/associatable.rb

@@ -0,0 +1,70 @@
+require_relative 'model_base'
+require 'active_support/inflector'
+
+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 = {})
+    defaults = {
+      foreign_key: "#{name.to_s.underscore}_id".to_sym,
+      primary_key: :id,
+      class_name: name.to_s.camelcase.singularize
+    }.merge(options)
+    defaults.each do |attribute, value|
+      self.send("#{attribute}=", value)
+    end
+  end
+end
+
+class HasManyOptions < 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
+    }.merge(options)
+    defaults.each do |attribute, value|
+      self.send("#{attribute}=", value)
+    end
+  end
+end
+
+module Associatable
+  def belongs_to(name, options = {})
+    assoc_options[name] = options = BelongsToOptions.new(name, options)
+    define_method(name) do
+      foreign_key_value = send(options.foreign_key)
+      model_class = options.model_class
+      model_class.where(options.primary_key => foreign_key_value).first
+    end
+  end
+
+  def has_many(name, options = {})
+    options = HasManyOptions.new(name, self.name, options)
+    define_method(name) do
+      options.model_class.where( options.foreign_key => id )
+    end
+  end
+
+  def assoc_options
+    @assoc_options ||= {}
+  end
+end
+
+class ModelBase
+  extend Associatable
+end

data/lib/reloj/orm/associatable2.rb

@@ -0,0 +1,34 @@
+require_relative 'associatable'
+
+module Associatable
+  # Remember to go back to 04_associatable to write ::assoc_options
+
+  def has_one_through(name, through_name, source_name)
+    self_options = assoc_options[name]
+    through_options = assoc_options[through_name]
+    #very close to finishing
+    define_method(name) do
+      # p all your assoc_options keys/values
+      source_options = through_options.model_class.assoc_options[source_name]
+      source_table = source_options.table_name
+      through_table = through_options.table_name
+      x = DBConnection.execute(<<-SQL)
+        SELECT
+          #{source_table}.*
+        FROM
+          #{source_table}
+        INNER JOIN
+          #{through_table}
+        ON
+          #{source_table}.id = #{through_table}.#{source_options.foreign_key}
+        INNER JOIN
+          #{self.class.table_name}
+        ON
+          #{self.class.table_name}.#{through_options.foreign_key} = #{through_table}.id;
+      SQL
+
+      source_options.model_class.parse_all(x).first
+      # use constantize
+    end
+  end
+end