odex 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1c7c61c0f5000ec3c865c9a1c08de459df7f7ae2
+  data.tar.gz: a0e3d37c71ed16f5939f4ef2a4d0d61fe79b24b1
+SHA512:
+  metadata.gz: 379ec12671a1b51038c9abe0408bcbcc2b827f2f8e19264080f6295599ab4fad2c5d4c2c1284d273acaede716c73036889fe78b6d9c0385fa99a04515c092ca3
+  data.tar.gz: 34d036481807d30be53abbb6891691b7c3f06f18cfbb95f9d1ed88673117c6a53ea08623d67692174f4cdb0783029b818af4c5eee395435e895aae05681d531f

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+gemspec
+
+group :test do
+  gem 'coveralls', :require => false
+end

data/README.md

@@ -0,0 +1,34 @@
+# Odex.
+Small web framework.
+
+```ruby
+# odex_test.rb
+
+require 'odex'
+class App < Odex::App
+  get '/' do
+    'Hello world!'
+  end
+end
+
+App.go(3000)!
+```
+
+Run the file:
+
+```bash
+ruby myapp.rb
+```
+Install the gem:
+
+```bash
+gem install odex
+```
+
+# Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

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

data/lib/odex/app.rb

@@ -0,0 +1,245 @@
+module Odex
+  # Odex Builder
+  class OdexBuilder < Rack::Builder
+  end
+
+  # Odex Request
+  class OdexRequest < ActionDispatch::Journey::Routes
+  end
+
+  # Odex Router
+  class OdexRouter < ActionDispatch::Journey::Router
+  end
+
+  # Odex Pattern
+  class OdexPattern < ActionDispatch::Journey::Path::Pattern
+  end
+
+  # Request
+
+  class Req
+    extend Forwardable
+
+    attr_reader :request, :response
+    def_delegators :request, :session, :params
+    def_delegators :response, :headers
+
+    def initialize(env)
+      @request  = Request.new(env)
+      @request.params.merge!(env['odex.params'])
+      @response = Response.new([], 200, {'Content-Type' => 'text/html'})
+    end
+
+    def cookies
+      @cookies ||= Rack::Cookies::CookieJar.new(request.cookies)
+    end
+
+    def status(code)
+      response.status = code
+    end
+
+    def halt(status, headers={}, body='')
+      @response = Response.new(body, status, headers)
+      cookies.finish!(response) if @cookies
+      throw(:halt, response)
+    end
+
+    def system_redirect_to(uri, status=302)
+      halt(status, {'Location' => uri})
+    end
+    alias_method :redirect, :system_redirect_to
+
+    def apply_to(&handler)
+      data = instance_eval(&handler)
+      data.respond_to?(:each) ? response.body = data : response.write(data)
+      cookies.finish!(response) if @cookies
+      response
+    end
+  end
+
+  # Router
+
+  class Router
+    attr_reader :c, :od_jr, :hook_before, :hook_after, :fallback
+    def initialize(options)
+      @c    = options[:c]
+      @hook_before   = options[:hook_before]
+      @hook_after    = options[:hook_after]
+      @fallback       = options[:fallback]
+
+      prepare_for_od_jr(options[:route_defs])
+    end
+
+    def call(env)
+      response = od_jr.call(env)
+
+      if response[0] == 40 and
+        fallback.call(env)
+      else
+        response
+      end
+    end
+
+    def prepare_for_od_jr(route_defs)
+      routes = Odex::OdexRequest.new
+      @od_jr = Odex::OdexRouter.new(routes, {
+        :parameters_key => 'odex.params',
+        :request_class => Odex::Request
+      })
+
+      route_defs.each do |path, options, handler|
+        pat         = Odex::OdexPattern.new(path)
+        constraints = options.fetch(:constraints, {})
+        defaults    = options.fetch(:defaults, {})
+
+        @od_jr.routes.add_route compile(handler), pat, constraints, defaults
+      end
+    end
+
+    def compile(handler)
+      Proc.new do |env|
+        scope = c.new(env)
+
+        response = catch (:halt) do
+          hook_before.each {|h| scope.instance_eval &h }
+          scope.apply_to &handler
+        end
+
+        catch (:halt) do
+          hook_after.each {|h| scope.instance_eval &h }
+        end
+
+        response.finish
+      end
+    end
+  end
+
+  # Initializer
+
+  module Init
+    def self.included(base)
+      base.class_eval do
+        def self.init_methods name, value
+          @_methods ||= []
+          @_methods << name
+          self.class.send(:attr_accessor, name)
+          self.send("#{name}=", value)
+        end
+
+        def self.inherited(subclass)
+          @_methods.each do |attr|
+            subclass.init_methods attr, self.send(attr).deep_dup
+          end
+        end
+      end
+    end
+  end
+
+  # Rack Request
+  class Request < Rack::Request
+    def params
+      @params ||= ActiveSupport::HashWithIndifferentAccess.new(super)
+    end
+  end
+
+  # Rack Response
+
+  class Response < Rack::Response
+  end
+
+  # Odex Base
+
+  class Base
+    include Odex::Init
+    METHODS = [:options, :patch, :post, :put, :trace, :delete, :get, :head]
+
+    init_methods :c,         Class.new(Req)
+    init_methods :route_defs,          []
+    init_methods :hook_before,        []
+    init_methods :hook_after,         []
+    init_methods :default_constraints, {}
+    init_methods :map,                 {}
+
+    def initialize(app=nil)
+      builder = odex_rack_builder
+      builder.run Router.new({
+        :c    => self.class.c,
+        :route_defs     => self.class.route_defs,
+        :hook_before   => self.class.hook_before,
+        :hook_after    => self.class.hook_after,
+        :fallback       => app
+      })
+
+      @app = builder.to_app
+    end
+
+    def odex_rack_builder
+      rack_builder = Odex::OdexBuilder.new
+      self.class.map.each do |url, map_class|
+        rack_builder.map(url) do
+          use map_class
+        end
+      end
+      rack_builder
+    end
+
+    def call env
+      @app.call env
+    end
+
+    class << self
+      METHODS.each do |method|
+        define_method method do |path, options={}, &block|
+          options[:constraints] = options[:constraints] || {}
+          options[:constraints].merge!(:request_method => method.to_s.upcase)
+          route path, options, &block
+        end
+      end
+
+      def group(url, app=nil, &block)
+        scope  = self.c
+
+        app ||= Class.new(self.superclass) do
+          self.c = scope
+          class_eval(&block)
+        end
+
+        map[url] = app
+      end
+
+      def before_proc(&block)
+        hook_before << Proc.new(&block)
+      end
+
+      def after_proc(&block)
+        hook_after << Proc.new(&block)
+      end
+
+      def ext(*extensions)
+        extensions.each do |ext|
+          extend ext
+          ext.module_is_registered(self) if ext.respond_to?(:module_is_registered)
+        end
+      end
+
+      def helpers(*args, &block)
+        args << Module.new(&block) if block_given?
+        args.each {|m| c.send :include, m }
+      end
+
+      def route(path, options, &block)
+        self.route_defs << [path, options, Proc.new(&block)]
+      end
+
+    end
+  end
+
+  class App < Base
+    class << self
+      def go!(port = 1453)
+        Rack::Handler.pick(['webrick']).run new, :Port => port
+      end
+    end
+  end
+
+end

data/lib/odex/modules/templates.rb

@@ -0,0 +1,22 @@
+require 'tilt'
+require 'slim'
+
+module Odex
+  module Templates
+    module Helpers
+      def render template, locals = {}, options = {}, &block
+        template_cache.fetch(template) do
+          Slim::Template.new(template, options)
+        end.render(self, locals, &block)
+      end
+
+      def template_cache
+        Thread.current[:template_cache] ||= Tilt::Cache.new
+      end
+    end
+
+    def self.module_is_registered app
+      app.helpers Helpers
+    end
+  end
+end

data/lib/odex/version.rb

@@ -0,0 +1,3 @@
+module Odex
+  VERSION = "0.0.1"
+end

data/lib/odex.rb

@@ -0,0 +1,19 @@
+# Version
+require 'odex/version'
+
+# General
+require 'rack'
+require 'active_support/hash_with_indifferent_access'
+require 'active_support/core_ext/object/deep_dup'
+require 'forwardable'
+require 'rack/contrib/cookies'
+require 'active_support/concern'
+require 'action_dispatch/routing'
+require 'action_dispatch/journey'
+require 'pathname'
+
+# Modules
+require 'odex/modules/templates'
+
+# Application
+require 'odex/app'

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification
+name: odex
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Sedat ÇİFTÇİ
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-08-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.14.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.14.1
+description: Small web framework.
+email:
+- me@sedat.us
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- Gemfile
+- Rakefile
+- lib/odex/app.rb
+- lib/odex/modules/templates.rb
+- lib/odex/version.rb
+- lib/odex.rb
+homepage: http://odex.sedat.us
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: Odex
+test_files: []