happy 0.0.1 → 0.1.0.pre.1

data/happy.gemspec

@@ -14,4 +14,9 @@ Gem::Specification.new do |gem|
   gem.name          = "happy"
   gem.require_paths = ["lib"]
   gem.version       = Happy::VERSION
+
+  gem.add_dependency 'activesupport', '~> 3.1'
+  gem.add_dependency 'rack', '~> 1.4'
+  gem.add_dependency 'happy-helpers' # TODO: , '~> 0.1.0'
+  gem.add_dependency 'allowance', '>= 0.1.1'
 end

data/lib/happy/actions.rb

@@ -0,0 +1,78 @@
+module Happy
+  module Actions
+    def serve!(data, options = {})
+      # Don't serve if there are still bits of path remaining.
+      return unless remaining_path.empty?
+
+      # Don't serve is data is not a string.
+      return unless data.is_a?(String)
+
+      # Mix in default options
+      options = {
+        layout: context.layout
+      }.merge(options)
+
+      # Add optional headers et al
+      response.status = options[:status] if options.has_key?(:status)
+      response['Content-type'] = options[:content_type] if options.has_key?(:content_type)
+
+      # Apply layout, if available
+      if options[:layout]
+        data = render(options[:layout]) { data }
+      end
+
+      # Set response body and finish request
+      response.body = [data]
+      halt!
+    end
+
+    def halt!(message = :done)
+      throw message
+    end
+
+    def redirect!(to, status = 302)
+      header "Location", url_for(to)
+      response.status = status
+      halt!
+    end
+
+    def layout(name)
+      context.layout = name
+    end
+
+    def content_type(type)
+      header 'Content-type', type
+    end
+
+    def max_age(t, options = {})
+      options = {
+        :public => true,
+        :must_revalidate => true
+      }.merge(options)
+
+      s = []
+      s << 'public' if options[:public]
+      s << 'must-revalidate' if options[:must_revalidate]
+      s << "max-age=#{t.to_i}"
+
+      cache_control s.join(', ')
+    end
+
+    def cache_control(s)
+      header 'Cache-control', s
+    end
+
+    def header(name, value)
+      response[name] = value
+    end
+
+    def invoke(klass, options = {}, &blk)
+      klass.new(env, options, &blk).perform
+    end
+
+    def run(app)
+      context.response = app.call(request.env)
+      halt!
+    end
+  end
+end

data/lib/happy/context.rb

@@ -0,0 +1,47 @@
+require 'happy/request'
+require 'happy/helpers'
+
+module Happy
+  class Context
+    include Helpers
+
+    attr_reader   :request, :response, :remaining_path
+    attr_accessor :layout, :controller
+    delegate      :params, :session, :to => :request
+
+    def initialize(request, response)
+      @request    = request
+      @response   = response
+      @remaining_path = @request.path.split('/').reject {|s| s.blank? }
+      @layout     = nil
+      @controller = nil
+    end
+
+    def with_controller(new_controller)
+      # remember previous controller
+      old_controller = self.controller
+      self.controller = new_controller
+
+      # execute permissions block
+      controller.class.permissions_blk.try(:call, permissions, self)
+
+      # execute block
+      yield
+    ensure
+      # switch back to previous controller
+      self.controller = old_controller
+    end
+
+    def response=(r)
+      @response = r
+    end
+
+  private
+
+    class << self
+      def from_env(env)
+        new(Happy::Request.new(env), Rack::Response.new)
+      end
+    end
+  end
+end

data/lib/happy/controller.rb

@@ -0,0 +1,55 @@
+require 'happy/routing'
+require 'happy/actions'
+require 'happy/rackable'
+
+module Happy
+  class Controller
+    include Routing
+    include Actions
+    include Rackable
+
+    attr_reader :options, :env
+
+    delegate :request, :response, :remaining_path, :params, :session,
+      :render, :url_for,
+      :to => :context
+
+    def initialize(env = nil, options = {}, &blk)
+      @env = env
+      @options = options
+      instance_exec(&blk) if blk
+    end
+
+    def perform
+      context.with_controller(self) do
+        route
+      end
+    end
+
+  private
+
+    def context
+      @env['happy.context'] ||= self.class.context_class.from_env(@env)
+    end
+
+    def route
+      instance_exec(&self.class.route_blk) if self.class.route_blk
+    end
+
+    class << self
+      attr_reader :route_blk
+
+      def route(&blk)
+        @route_blk = blk
+      end
+
+      def context(&blk)
+        context_class.class_exec(&blk)
+      end
+
+      def context_class
+        Happy::Context
+      end
+    end
+  end
+end

data/lib/happy/helpers.rb

@@ -0,0 +1,37 @@
+require 'happy-helpers'
+
+module Happy
+  module Helpers
+    include HappyHelpers::Helpers
+
+    def render(what, options = {}, &blk)
+      case what
+        when String     then render_template(what, options, &blk)
+        when Enumerable then what.map { |i| render(i, options, &blk) }.join
+        else render_resource(what, options)
+      end
+    end
+
+    def render_template(name, variables = {}, &blk)
+      HappyHelpers::Templates.render(name, self, variables, &blk)
+    end
+
+    def render_resource(resource, options = {})
+      # build name strings
+      singular_name = resource.class.to_s.tableize.singularize
+      plural_name   = singular_name.pluralize
+
+      # set options
+      options = {
+        singular_name => resource
+      }.merge(options)
+
+      # render
+      render_template("#{plural_name}/_#{singular_name}.html.haml", options)
+    end
+
+    alias_method :h, :escape_html
+    alias_method :l, :localize
+    alias_method :t, :translate
+  end
+end

data/lib/happy/permissions.rb

@@ -0,0 +1,34 @@
+module Happy
+  module Permissions
+    module ContextExtensions
+      extend ActiveSupport::Concern
+
+      def permissions(&blk)
+        @permissions ||= Allowance.define
+      end
+
+      def can?(*args)
+        permissions.allowed?(*args)
+      end
+    end
+
+    module ControllerExtensions
+      extend ActiveSupport::Concern
+
+      included do
+        delegate :can?, :to => :context
+      end
+
+      module ClassMethods
+        attr_accessor :permissions_blk
+
+        def permissions(&blk)
+          self.permissions_blk = blk
+        end
+      end
+    end
+  end
+end
+
+Happy::Context.send(:include, Happy::Permissions::ContextExtensions)
+Happy::Controller.send(:include, Happy::Permissions::ControllerExtensions)

data/lib/happy/rackable.rb

@@ -0,0 +1,24 @@
+module Happy
+  module Rackable
+    extend ActiveSupport::Concern
+
+    def call(env)
+      @env = env
+
+      catch :done do
+        serve! perform
+
+        # If we get here, #serve decided not to serve.
+        raise NotFoundError
+      end
+
+      response
+    end
+
+    module ClassMethods
+      def call(env)
+        new.call(env)
+      end
+    end
+  end
+end

data/lib/happy/request.rb

@@ -0,0 +1,13 @@
+require 'happy-helpers/utils/date_parameter_converter'
+
+module Happy
+  class Request < Rack::Request
+  protected
+
+    def parse_query(qs)
+      super(qs).tap do |p|
+        HappyHelpers::Utils::DateParameterConverter.convert!(p)
+      end
+    end
+  end
+end

data/lib/happy/resources.rb

@@ -0,0 +1,112 @@
+module Happy
+  module Resources
+    module ControllerExtensions
+      def resource(klass, options = {}, &blk)
+        invoke Happy::Resources::ResourceMounter, options.merge(:class => klass), &blk
+      end
+    end
+
+    class ResourceMounter < Happy::Controller
+      def render_resource_template(name)
+        render "#{options[:plural_name]}/#{name}.html.haml"
+      end
+
+      def resource
+        options[:class]
+      end
+
+      def resource_with_permission_scope(*args)
+        context.permissions.scoped_model(*args, options[:class])
+      end
+
+      def require_permission!(*args)
+        raise "not allowed" unless can?(*args, options[:class])
+      end
+
+      def set_plural_variable(v)
+        context.instance_variable_set "@#{options[:plural_name]}", v
+      end
+
+      def plural_variable
+        context.instance_variable_get "@#{options[:plural_name]}"
+      end
+
+      def set_singular_variable(v)
+        context.instance_variable_set "@#{options[:singular_name]}", v
+      end
+
+      def singular_variable
+        context.instance_variable_get "@#{options[:singular_name]}"
+      end
+
+      def do_index
+        require_permission! :index
+        set_plural_variable resource_with_permission_scope(:index).all
+        render_resource_template 'index'
+      end
+
+      def do_show
+        require_permission! :show
+        set_singular_variable resource_with_permission_scope(:show).find(params['id'])
+        render_resource_template 'show'
+      end
+
+      def do_new
+        require_permission! :new
+        set_singular_variable resource_with_permission_scope(:new).new(params[options[:singular_name]], :as => options[:role])
+        render_resource_template 'new'
+      end
+
+      def do_create
+        require_permission! :create
+        set_singular_variable resource_with_permission_scope(:create).new(params[options[:singular_name]], :as => options[:role])
+
+        if singular_variable.save
+          redirect! singular_variable
+        else
+          render_resource_template 'new'
+        end
+      end
+
+      def do_edit
+        require_permission! :edit
+        set_singular_variable resource_with_permission_scope(:edit).find(params['id'])
+        render_resource_template 'edit'
+      end
+
+      def do_update
+        require_permission! :update
+        set_singular_variable resource_with_permission_scope(:update).find(params['id'])
+        singular_variable.assign_attributes params[options[:singular_name]], :as => options[:role]
+
+        if singular_variable.save
+          redirect! singular_variable
+        else
+          render_resource_template 'edit'
+        end
+      end
+
+      def route
+        @options = {
+          singular_name: options[:class].to_s.tableize.singularize,
+          plural_name:   options[:class].to_s.tableize.pluralize
+        }.merge(@options)
+
+        path options[:plural_name] do
+          get('new') { do_new }
+
+          path :id do
+            get         { do_show }
+            post        { do_update }
+            get('edit') { do_edit }
+          end
+
+          post { do_create }
+          get  { do_index }
+        end
+      end
+    end
+  end
+end
+
+Happy::Controller.send(:include, Happy::Resources::ControllerExtensions)

data/lib/happy/routing.rb

@@ -0,0 +1,56 @@
+module Happy
+  module Routing
+    def path_to_regexp(path)
+      path = ":#{path}" if path.is_a?(Symbol)
+      Regexp.compile('^'+path.gsub(/\)/, ')?').gsub(/\//, '\/').gsub(/\./, '\.').gsub(/:(\w+)/, '(?<\\1>.+)')+'$')
+    end
+
+    def path(*args, &blk)
+      options = (args.pop if args.last.is_a?(Hash)) || {}
+      args = [nil] if args.empty?
+
+      args.each do |name|
+        if name.present?
+          path_match = path_to_regexp(name).match(remaining_path.first)
+        end
+
+        method_matched = [nil, request.request_method.downcase.to_sym].include?(options[:method])
+        path_matched   = (path_match || (name.nil? && remaining_path.empty?))
+
+        # Only do something here if method and requested path both match
+        if path_matched && method_matched
+          # Transfer variables contained in path name to params hash
+          if path_match
+            path_match.names.each { |k| request.params[k] = path_match[k] }
+            remaining_path.shift
+          end
+
+          serve! instance_exec(&blk)
+
+          # If we get here, #serve decided not to serve.
+          raise NotFoundError
+        end
+      end
+    end
+
+    def get(*args, &blk)
+      args.last.is_a?(Hash) ? args.last.merge(method: :get) : args.push(method: :get)
+      path(*args, &blk)
+    end
+
+    def post(*args, &blk)
+      args.last.is_a?(Hash) ? args.last.merge(method: :post) : args.push(method: :post)
+      path(*args, &blk)
+    end
+
+    def put(*args, &blk)
+      args.last.is_a?(Hash) ? args.last.merge(method: :put) : args.push(method: :put)
+      path(*args, &blk)
+    end
+
+    def delete(*args, &blk)
+      args.last.is_a?(Hash) ? args.last.merge(method: :delete) : args.push(method: :delete)
+      path(*args, &blk)
+    end
+  end
+end

data/lib/happy/static.rb

@@ -0,0 +1,7 @@
+module Happy
+  class Static < Happy::Controller
+    def route
+      run Rack::File.new(options[:path])
+    end
+  end
+end

data/lib/happy/version.rb

@@ -1,3 +1,3 @@
 module Happy
-  VERSION = "0.0.1"
+  VERSION = "0.1.0.pre.1"
 end

data/lib/happy.rb

@@ -1,5 +1,14 @@
-require "happy/version"
+require 'active_support/all' # SMELL
+
+require 'happy/context'
+require 'happy/controller'
+require 'happy/static'
 
 module Happy
-  # Your code goes here...
+  class HappyError < StandardError ; end
+  class NotFoundError < HappyError ; end
+
+  def self.env
+    ActiveSupport::StringInquirer.new(ENV['RACK_ENV'] || 'development')
+  end
 end

metadata

@@ -1,8 +1,8 @@
 --- !ruby/object:Gem::Specification
 name: happy
 version: !ruby/object:Gem::Version
-  version: 0.0.1
-  prerelease: 
+  version: 0.1.0.pre.1
+  prerelease: 6
 platform: ruby
 authors:
 - Hendrik Mans
@@ -10,7 +10,51 @@ autorequire:
 bindir: bin
 cert_chain: []
 date: 2012-05-31 00:00:00.000000000 Z
-dependencies: []
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: &70164769147200 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70164769147200
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: &70164769146300 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70164769146300
+- !ruby/object:Gem::Dependency
+  name: happy-helpers
+  requirement: &70164769145860 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70164769145860
+- !ruby/object:Gem::Dependency
+  name: allowance
+  requirement: &70164769145220 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.1.1
+  type: :runtime
+  prerelease: false
+  version_requirements: *70164769145220
 description: A happy little toolkit for writing web applications.
 email:
 - hendrik@mans.de
@@ -25,6 +69,16 @@ files:
 - Rakefile
 - happy.gemspec
 - lib/happy.rb
+- lib/happy/actions.rb
+- lib/happy/context.rb
+- lib/happy/controller.rb
+- lib/happy/helpers.rb
+- lib/happy/permissions.rb
+- lib/happy/rackable.rb
+- lib/happy/request.rb
+- lib/happy/resources.rb
+- lib/happy/routing.rb
+- lib/happy/static.rb
 - lib/happy/version.rb
 homepage: https://github.com/hmans/happy
 licenses: []
@@ -41,9 +95,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
-  - - ! '>='
+  - - ! '>'
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.11