generic 0.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: dd6950356e997c63545003fcfdb3009fc75159b1
+  data.tar.gz: e75f52114b5311e2b398eb3a5ede128ae36caf74
+SHA512:
+  metadata.gz: 3dd444b799993ef39d8516d4cc917b7db0f7996d7f12dbae047d25056bd5cc9075d35bd928e89bdee1ff34e326d3644c5c2cdec5f00cf34843960f8b0981bb9e
+  data.tar.gz: ba594f139687a12ebdbc3118eb07f26e8c21ce7c083d9cf9b2462e465ee0a5de1fec2f1e56488b7a83e2f6cb74771fb53d9979719a6812ff654b44bcdb28d794

data/Gemfile

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

data/README.md

@@ -0,0 +1,31 @@
+# Generic
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'generic'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install generic
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/generic/fork )
+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 a new Pull Request

data/Rakefile

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

data/bin/generic

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+# coding: utf-8
+
+require "optparse"
+require "fileutils"
+
+include FileUtils
+

data/lib/generic.rb

@@ -0,0 +1,2 @@
+require "generic/version"
+require "generic/boot"

data/lib/generic/boot.rb

@@ -0,0 +1,10 @@
+require "generic/generic"
+module Generic
+  class Boot < Base
+    class << self
+      def go!(server_port = 1453)
+        Rack::Handler.pick(['webrick']).run new, :Port => server_port
+      end
+    end
+  end
+end

data/lib/generic/generic.rb

@@ -0,0 +1,184 @@
+require 'rack'
+require 'active_support/hash_with_indifferent_access'
+require 'active_support/core_ext/object/deep_dup'
+require 'pathname'
+require 'generic/target'
+require 'generic/routing'
+
+module Generic
+
+  class Request < Rack::Request
+    def params
+      @params ||= ActiveSupport::HashWithIndifferentAccess.new(super)
+    end
+  end
+
+  class InsEval
+    def self.instance(scope, &block)
+      scope.instance_eval &block
+    end
+
+    def self.apply(scope, &handler)
+      scope.apply &handler
+    end
+
+    def self.hand(scope_class, handler, before_actions, after_actions)
+      Proc.new do |env|
+        scope = scope_class.new(env)
+        response = catch (:halt) do
+          before_actions.each do |action|
+            Generic::InsEval.instance(scope, &action)
+          end
+          Generic::InsEval.apply(scope, &handler)
+        end
+        catch (:halt) do
+          after_actions.each do |action|
+            Generic::InsEval.apply(scope, &action)
+          end
+        end
+        response.finish
+      end
+    end
+
+  end
+
+  class Response < Rack::Response
+  end
+
+  def self.root
+    @root ||= Pathname.pwd
+  end
+
+  class Base
+    include Genericer::General
+
+    # General
+    general(:scope, Class.new(Target))
+    general(:rd, [])
+    general(:before_actions, [])
+    general(:after_actions, [])
+    general(:guard, {})
+    general(:routes, {})
+    general(:impt, [])
+
+    def initialize(app=nil)
+      # Rack Builder
+      builder = Rack::Builder.new
+
+      #Register Importing Classes
+      self.class.impt.each do |im, args, block|
+        builder.use(im, *args, &block)
+      end
+
+      # Register group nested
+      self.class.routes.each do |url, a_class|
+        builder.map(url) do
+          use a_class
+        end
+      end
+
+      builder.run Generic::Routing.new({
+                                           :scope => self.class.scope,
+                                           :rd => self.class.rd,
+                                           :before_actions => self.class.before_actions,
+                                           :after_actions => self.class.after_actions,
+                                           :fail => app
+                                       })
+
+      @app = builder.to_app
+    end
+
+
+    def call(env)
+      @app.call(env)
+    end
+
+    class << self
+
+      # Methods
+
+      def get(path, options={}, &block)
+        options[:constraints] = guard.merge(options[:constraints] || {})
+        options[:constraints].merge!(:request_method => "GET")
+        define_route(path, options, &block)
+      end
+
+      def post(path, options={}, &block)
+        options[:constraints] = guard.merge(options[:constraints] || {})
+        options[:constraints].merge!(:request_method => "POST")
+        define_route(path, options, &block)
+      end
+
+      def put(path, options={}, &block)
+        options[:constraints] = guard.merge(options[:constraints] || {})
+        options[:constraints].merge!(:request_method => "PUT")
+        define_route(path, options, &block)
+      end
+
+      def delete(path, options={}, &block)
+        options[:constraints] = guard.merge(options[:constraints] || {})
+        options[:constraints].merge!(:request_method => "DELETE")
+        define_route(path, options, &block)
+      end
+
+      # Group Route
+      def group(url, app=nil, &block)
+        scope = self.scope
+        app = Class.new(self.superclass) do
+          self.scope = scope
+          class_eval(&block)
+        end
+        routes[url] = app
+      end
+
+      # Register Extension
+      def register(*extensions)
+        extensions.each do |ext|
+          extend ext
+          if ext.check(self)
+            ext.respond_to?(:registered)
+          end
+        end
+      end
+
+      # Set Guard
+      def set_guard(args, &block)
+        current = self.guard.dup
+        self.guard = args
+        instance_eval(&block)
+        self.guard = current
+      end
+
+      # System Helper
+      def helpers(*args, &block)
+        if block_given?
+          args << Module.new(&block)
+        end
+        args.each do |m|
+          scope.send :include, m
+        end
+      end
+
+      # Import
+      def import(cls, *args, &block)
+        impt << [cls, args, block]
+      end
+
+      # Before Proccess
+      def before(&block)
+        before_actions << Proc.new(&block)
+      end
+
+      # After Proccess
+      def after(&block)
+        after_actions << Proc.new(&block)
+      end
+
+      protected
+      # Define Framework Route
+      def define_route(path, options, &block)
+        self.rd << [path, options, Proc.new(&block)]
+      end
+    end
+  end
+end

data/lib/generic/help.rb

@@ -0,0 +1,3 @@
+module Generic
+  HELP = ""
+end

data/lib/generic/routing.rb

@@ -0,0 +1,76 @@
+require 'active_support/concern'
+require 'action_dispatch/routing'
+require 'action_dispatch/journey'
+
+module Genericer
+  class DJRoutes < ActionDispatch::Journey::Routes
+    def initialize
+      super
+    end
+  end
+  class DJRouter < ActionDispatch::Journey::Router
+    def initialize(routes, params)
+      super
+    end
+  end
+  class DJJourner < ActionDispatch::Journey::Path::Pattern
+    def initialize(path)
+      super
+    end
+  end
+  module General
+    def self.included(base)
+      base.class_eval do
+        def self.general(name, value)
+          @g ||= []
+          @g << name
+          self.class.send(:attr_accessor, name)
+          self.send("#{name}=", value)
+        end
+
+        def self.inherited(sc)
+          @g.each do |a|
+            sc.general(a, self.send(a).deep_dup)
+          end
+        end
+      end
+    end
+  end
+end
+
+module Generic
+  class Routing
+    attr_reader :scope, :jr, :before_actions, :after_actions, :fail
+
+    def initialize(options)
+      @scope    = options[:scope]
+      @before_actions   = options[:before_actions]
+      @after_actions    = options[:after_actions]
+      @fail       = options[:fail]
+      ready(options[:rd])
+    end
+
+    def call(env)
+      response = jr.call(env)
+      if response[0] == 404 and fail
+        fail.call(env)
+      else
+        response
+      end
+    end
+
+    def ready(rd)
+      routes = Genericer::DJRoutes.new
+      @jr = Genericer::DJRouter.new(routes, {})
+      rd.each do |path, options, handler|
+        pat         = Genericer::DJJourner.new(path)
+        guard       = options.fetch(:guard, {})
+        defaults    = options.fetch(:defaults, {})
+        @jr.routes.add_route(Generic::InsEval.hand(scope, handler, before_actions, after_actions),
+                                  pat,
+                                  guard,
+                                  defaults)
+      end
+    end
+  end
+end

data/lib/generic/target.rb

@@ -0,0 +1,49 @@
+require 'forwardable'
+require 'rack/contrib/cookies'
+
+module Generic
+  class Target
+    extend Forwardable
+
+    attr_reader :request, :response
+    def_delegators :request, :session, :params
+    def_delegators :response, :headers
+
+    def initialize(p)
+      @request = Request.new(p)
+      @response = Response.new [], 200, {'Content-Type' => 'text/html'}
+    end
+
+    private
+
+    def system_redirect(uri, status=302)
+      exit(status, {'Location' => uri})
+    end
+
+    def status(code)
+      response.status = code
+    end
+
+    def exit(status, headers={}, body='')
+      @response = Response.new(body, status, headers)
+      cookies.finish!(response) if @cookies
+      throw :halt, response
+    end
+
+    def system_cookies
+      @cookies ||= Rack::Cookies::CookieJar.new(request.cookies)
+    end
+
+    [:goto, :go_to].each do |keyword|
+      alias_method keyword, :system_redirect
+    end
+
+    public
+    def apply(&handler)
+      data = instance_eval(&handler)
+      data.respond_to?(:each) ? response.body = data : response.write(data)
+      cookies.finish!(response) if @cookies
+      response
+    end
+  end
+end

data/lib/generic/version.rb

@@ -0,0 +1,3 @@
+module Generic
+  VERSION = "0.0.3"
+end

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification
+name: generic
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+platform: ruby
+authors:
+- Write your name
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-08-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: Write a longer description. Optional.
+email:
+- Write your email address
+executables:
+- generic
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- Gemfile
+- Rakefile
+- lib/generic/boot.rb
+- lib/generic/generic.rb
+- lib/generic/help.rb
+- lib/generic/routing.rb
+- lib/generic/target.rb
+- lib/generic/version.rb
+- lib/generic.rb
+- bin/generic
+homepage: ''
+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: Write a short summary. Required.
+test_files: []