wd_sinatra 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

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

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Matt Aimonetti
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,148 @@
+# Weasel Diesel Sinatra
+
+Weasel-Diesel Sinatra app gem, allowing you to generate/update sinatra apps using the Weasel Diesel DSL
+
+
+## Installation
+
+    $ gem install 'wd_sinatra'
+
+## Usage
+
+### App generation
+
+Once the gem is installed, you can use the generator to create a new
+app. Go to the location where you want to generate a new app and type
+the following command (replace `<app_name>` by the name you want to
+application to have):
+
+    $ wd_sinatra <app_name>
+
+Check the newly generated app
+
+    $ cd <app_name>
+
+You'll need bundler to install the dependencies:
+
+    $ gem install bundler
+    $ bundle install
+
+### Starting the server
+
+The app is now ready to use, to start it you can use rack:
+
+    $ bundle exec rackup
+
+This will start the server on port 9292 and the default GET `/hello_world` service will be available at: `http://localhost:9292/hello_world'.
+
+Note that the code won't be reloading automatically in the server when
+you make a modification to the source code. For that, you might want to
+use Puma + [Guard](https://github.com/jc00ke/guard-puma) or another tool that allows you to do that.
+While it's a nice feature to have, a lot of developers like to do that
+differently and it seems more sensitive to let them pick the way they
+like the most.
+
+### Console
+
+    $ bundle exec bin/console
+
+The console mode is like the server mode but without the server only
+concerns such as the sinatra routes config and Rack middleware.
+
+### Documentation generation
+
+    $ rake doc:services
+
+To generate documentation for the APIs you created in the api folder.
+
+### Testing
+
+TODO
+
+## Writing a service
+
+TODO see Weasel Diesel for now.
+
+## Config and hooks
+
+### app.rb
+
+The `config/app.rb` file is being required after the environment is set
+but before the models are loaded. This is the perfect place to load
+custom libraries and set your datastore.
+
+This is where you will for instance load ActiveRecord and set your DB
+connection.
+
+### Environments
+
+The files in `config/environments` can
+be used to set environment specific configuration or other.
+If you add a new environment such as staging, you can add a `staging.rb`
+file in the environments folder that will only get required when running
+in this env mode.
+Whatever the environment is, the `config/environments/default.rb` is
+being required before the specific env file.
+
+### Hooks
+
+The request dispatcher offers 3 hooks which you can see demonstrated in
+`config/hooks.rb`.
+
+* `params_preprocessor_hook(params)`
+* `params_postprocessor_hook(params)`
+* `pre_dispatch_hook`
+
+The two first hooks are used to process the params and when implemented
+are expected to return the params that will be used in the request.
+
+The `pre_dispatch_hook` is called just before the request is dispatched
+to the service implementation. This is where you might want to implement
+an authentication verification system for instance.
+
+These 3 hooks have access to the entire request context, including the
+`service` being called. You can use the service `extra` option to set
+some custom settings that can then be used in this pre dispatch hook.
+
+In the default generated application, a body parser is provided to parse
+JSON requests when the HTTP verb is PUT, POST or DELETE. The json parser is set by default to use the `JSON` module but you might want to change it to use Yajl for instance.
+To do that, edit the `config/hooks.rb` file and change the following:
+
+```ruby
+BodyParser.json_parser = JSON
+```
+
+to:
+
+```ruby
+BodyParser.json_parser = Yajl::Parser
+```
+
+Of course, you'll need to require `Yajl` first and add it to your
+Gemfile if you want to use Bundler.
+
+
+
+## Using an ORM
+
+TODO: see https://github.com/mattetti/sinatra-web-api-example/  for now
+for an example of setting up ActiveRecord.
+Eventually the generator will take an option to generate an AR, DM or
+other ORM template.
+
+## Update
+
+To update your app, just update your gem dependency on `wd_sinatra`, you
+can also compare the difference between your app and a freshly generated
+app by trying to generate a new app named the same as your old app.
+The generator will detect conflicts and let you pick an action (diff,
+overwrite, ignore...)
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/bin/wd_sinatra

@@ -0,0 +1,47 @@
+#!/usr/bin/env ruby
+require "rubygems"
+require "thor/group"
+
+class WdSinatra < Thor::Group
+  include Thor::Actions
+
+  # Define arguments and options
+  # argument :type, :type => :string, :desc => "The type to generate, app by default"
+  argument :name, :type => :string, :desc => "The name of the app to generate"
+  class_option :test_framework, :default => :test_unit
+
+  def self.source_root
+    File.expand_path(File.join('..', 'templates'), File.dirname(__FILE__))
+  end
+
+  def create_lib_directory
+    directory "lib", "#{name}/lib"
+  end
+
+  def create_config_directory
+    directory "config", "#{name}/config"
+  end
+
+  def create_bin_directory
+    directory "bin", "#{name}/bin"
+    chmod "#{name}/bin/console", 0755
+  end
+
+  def create_public_directory
+    directory "public", "#{name}/public"
+  end
+
+  def create_api_directory
+    directory "api", "#{name}/api"
+  end
+
+  def create_files
+    copy_file "Rakefile", "#{name}/Rakefile"
+    copy_file "Gemfile", "#{name}/Gemfile"
+    copy_file "config.ru", "#{name}/config.ru"
+    copy_file "Guardfile", "#{name}/Guardfile"
+  end
+
+end
+
+WdSinatra.start

data/lib/wd_sinatra.rb

@@ -0,0 +1,7 @@
+require "wd_sinatra/version"
+
+module WD
+  module Sinatra
+    # Your code goes here...
+  end
+end

data/lib/wd_sinatra/app_loader.rb

@@ -0,0 +1,120 @@
+if RUBY_VERSION =~ /1.8/
+  require 'rubygems'
+  require 'backports'
+end
+require 'bundler'
+Bundler.setup
+require 'logger'
+require 'weasel_diesel'
+
+module WDSinatra
+  module AppLoader
+    module_function
+
+    # Boot in server mode
+    def server(root_path)
+      @root = root_path
+      unless @booted
+        console(root_path)
+        load_middleware
+        set_sinatra_routes
+        set_sinatra_settings
+      end
+    end
+
+    # Boot in console mode
+    def console(root_path)
+      @root = root_path
+      unless @booted
+        set_env
+        set_loadpath
+        load_environment
+        load_lib_dependencies
+        load_app_config
+        load_models
+        load_apis
+        @booted =  true
+      end
+    end
+
+    def root_path
+      @root
+    end
+
+    # PRIVATE
+
+    # Sets the environment (RACK_ENV) based on some env variables.
+    def set_env
+      if !Object.const_defined?(:RACK_ENV)
+        ENV['RACK_ENV'] ||= ENV['RAILS_ENV'] || 'development'
+        Object.const_set(:RACK_ENV, ENV['RACK_ENV'])
+      end
+      puts "Running in #{RACK_ENV} mode" if RACK_ENV == 'development'
+    end
+
+
+    # Loads an environment specific config if available, the config file is where the logger should be set
+    # if it was not, we are using stdout.
+    def load_environment(env=RACK_ENV)
+      # Load the default which can be overwritten or extended by specific
+      # env config files.
+      require File.join(root_path, 'config', 'environments', 'default.rb')
+      env_file = File.join(root_path, "config", "environments", "#{env}.rb")
+      if File.exist?(env_file)
+        require env_file
+      else
+        debug_msg = "Environment file: #{env_file} couldn't be found, using only the default environment config instead." unless env == 'development'
+      end
+      # making sure we have a LOGGER constant defined.
+      unless Object.const_defined?(:LOGGER)
+        Object.const_set(:LOGGER, Logger.new($stdout))
+      end
+      LOGGER.debug(debug_msg) if debug_msg
+    end
+
+    def set_loadpath(root=nil)
+      root ||= root_path
+      $: << root
+      $: << File.join(root, 'lib')
+      $: << File.join(root, 'models')
+    end
+
+    def load_lib_dependencies
+      # WeaselDiesel is the web service DSL gem used to define services.
+      require 'weasel_diesel'
+      require 'sinatra'
+      require 'wd_sinatra/sinatra_ext'
+      # TODO: hook to custom app dependencies
+    end
+
+    def load_app_config
+      require File.join(root_path, 'config', 'app')
+    end
+
+    def load_models
+      Dir.glob(File.join(root_path, "models", "**", "*.rb")).each do |model|
+        require model
+      end
+    end
+
+    # DSL routes are located in the api folder
+    def load_apis
+      Dir.glob(File.join(root_path, "api", "**", "*.rb")).each do |api|
+        require api
+      end
+    end
+
+    def set_sinatra_routes
+      WSList.all.sort.each{|api| api.load_sinatra_route }
+    end
+
+    def load_middleware
+      require File.join(root_path, 'config', 'middleware')
+    end
+
+    def set_sinatra_settings
+      require File.join(root_path, 'config', 'sinatra_config')
+    end
+
+  end
+end

data/lib/wd_sinatra/sinatra_ext.rb

@@ -0,0 +1,117 @@
+require 'forwardable'
+require 'params_verification'
+require 'json'
+
+class WeaselDiesel
+
+  class RequestHandler
+    extend Forwardable
+
+    # @return [WeaselDiesel] The service served by this controller
+    # @api public
+    attr_reader :service
+
+    # @return [Sinatra::Application]
+    # @api public
+    attr_reader :app
+
+    # @return [Hash]
+    # @api public
+    attr_reader :env
+
+    # @return [Sinatra::Request]
+    # @see http://rubydoc.info/github/sinatra/sinatra/Sinatra/Request
+    # @api public
+    attr_reader :request
+
+    # @return [Sinatra::Response]
+    # @see http://rubydoc.info/github/sinatra/sinatra/Sinatra/Response
+    # @api public
+    attr_reader :response
+
+    # @return [Hash]
+    # @api public
+    attr_accessor :params
+
+    attr_accessor :current_user
+
+    # The service controller might be loaded outside of a Sinatra App
+    # in this case, we don't need to load the helpers
+    if Object.const_defined?(:Sinatra)
+      include Sinatra::Helpers
+    end
+
+    def initialize(service, &block)
+      @service = service
+      @implementation = block
+    end
+
+    def dispatch(app)
+      @app      = app
+      @env      = app.env
+      @request  = app.request
+      @response = app.response
+      @service  = service
+  
+      begin
+        # raises an exception if the params are not valid
+        # otherwise update the app params with potentially new params (using default values)   
+        # note that if a type is mentioned for a params, the object will be cast to this object type 
+        #
+        # removing the fake sinatra params since v1.3 added this. (should be eventually removed)
+        if app.params['splat']
+          processed_params = app.params.dup
+          processed_params.delete('splat')
+          processed_params.delete('captures')
+        end
+        @params = (processed_params || app.params)
+        @params = params_preprocessor_hook(@params) if self.respond_to?(:params_preprocessor_hook)
+        @params = ParamsVerification.validate!(@params, service.defined_params)
+        @params = params_postrocessor_hook(@params) if self.respond_to?(:params_postprocessor_hook)
+      rescue Exception => e
+        LOGGER.error e.message
+        LOGGER.error "passed params: #{app.params.inspect}"
+        halt 400, {:error => e.message}.to_json
+      end
+
+      # Define WeaselDiesel::RequestHandler#authorization_check in your app if
+      # you want to use an auth check.
+      pre_dispatch_hook if self.respond_to?(:pre_dispatch_hook)
+      service_dispatch
+    end
+
+    # Forwarding some methods to the underlying app object
+    def_delegators :app, :settings, :halt, :compile_template, :session
+ 
+    private ##################################################
+
+  end # of RequestHandler
+
+  attr_reader :handler
+
+  def implementation(&block)
+    if block_given?
+      @handler = RequestHandler.new(self, &block)
+      @handler.define_singleton_method(:service_dispatch, block)
+    end
+    @handler
+  end
+
+  def load_sinatra_route
+    service     = self
+    upcase_verb = service.verb.to_s.upcase
+    unless ENV['DONT_PRINT_ROUTES']
+      LOGGER.info "Available endpoint: #{self.http_verb.upcase} /#{self.url}" 
+    end
+    raise "DSL is missing the implementation block" unless self.handler && self.handler.respond_to?(:service_dispatch)
+
+    # Define the route directly to save some object allocations on the critical path
+    # Note that we are using a private API to define the route and that unlike sinatra usual DSL
+    # we do NOT define a HEAD route for every GET route.
+    Sinatra::Base.send(:route, upcase_verb, "/#{self.url}") do
+      service.handler.dispatch(self)
+    end
+    
+  end
+
+end