tentd 0.0.1

data/lib/tentd/api/profile.rb

@@ -0,0 +1,78 @@
+module TentD
+  class API
+    class Profile
+      include Router
+
+      class AuthorizeWrite < Middleware
+        def action(env)
+          authorize_env!(env, :write_profile)
+          env
+        end
+      end
+
+      class Get < Middleware
+        def action(env)
+          env.response = Model::ProfileInfo.get_profile(env.authorized_scopes, env.current_auth)
+          env
+        end
+      end
+
+      class Update < Middleware
+        def action(env)
+          data = env.params.data
+          type = URI.unescape(env.params.type_url)
+          raise Unauthorized unless ['all', type].find { |t| env.current_auth.profile_info_types.include?(t) }
+          env.updated_info = Model::ProfileInfo.update_profile(type, data)
+          env
+        end
+      end
+
+      class Patch < Middleware
+        def action(env)
+          diff_array = env.params[:data]
+          profile_hash = env.delete(:response)
+          new_profile_hash = Marshal.load(Marshal.dump(profile_hash)).to_hash # equivalent of recursive dup
+          JsonPatch.merge(new_profile_hash, diff_array)
+          if new_profile_hash != profile_hash
+            env.updated_info = new_profile_hash.map do |type, data|
+              Model::ProfileInfo.update_profile(type, data)
+            end
+          end
+          env
+        rescue JsonPatch::ObjectNotFound, JsonPatch::ObjectExists => e
+          env['response.status'] = 422
+          env
+        end
+      end
+
+      class Notify < Middleware
+        def action(env)
+          return env unless env.updated_info
+          Array(env.updated_info).each do |info|
+            Notifications.profile_info_update(:profile_info_id => info.id)
+          end
+          env
+        end
+      end
+
+      get '/profile' do |b|
+        b.use Get
+      end
+
+      put '/profile/:type_url' do |b|
+        b.use AuthorizeWrite
+        b.use Update
+        b.use Get
+        b.use Notify
+      end
+
+      patch '/profile' do |b|
+        b.use AuthorizeWrite
+        b.use Get
+        b.use Patch
+        b.use Get
+        b.use Notify
+      end
+    end
+  end
+end

data/lib/tentd/api/router.rb

@@ -0,0 +1,123 @@
+require 'rack/mount'
+require 'rack/head'
+
+class Rack::Mount::RouteSet
+  def merge_routes(routes)
+    routes.each { |r| merge_route(r) }
+    rehash
+  end
+
+  def merge_route(route)
+    @routes << route
+
+    @recognition_key_analyzer << route.conditions
+
+    @named_routes[route.name] = route if route.name
+    @generation_route_keys << route.generation_keys
+
+    expire!
+    route
+  end
+end
+
+module TentD
+  class API
+    module Router
+      autoload :ExtractParams, 'tentd/api/router/extract_params'
+      autoload :SerializeResponse, 'tentd/api/router/serialize_response'
+      autoload :CachingHeaders, 'tentd/api/router/caching_headers'
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      def call(env)
+        self.class.routes.call(env)
+      end
+
+      module ClassMethods
+        def mount(klass)
+          routes.merge_routes klass.routes.instance_variable_get("@routes")
+        end
+
+        def routes
+          @routes ||= Rack::Mount::RouteSet.new
+        end
+
+        #### This section heavily "inspired" by sinatra
+
+        # Defining a `GET` handler also automatically defines
+        # a `HEAD` handler.
+        def get(path, opts={}, &block)
+          route('GET', path, opts, &block)
+          route('HEAD', path, opts, &block)
+        end
+
+        def put(path, opts={}, &bk)     route 'PUT',     path, opts, &bk end
+        def post(path, opts={}, &bk)    route 'POST',    path, opts, &bk end
+        def delete(path, opts={}, &bk)  route 'DELETE',  path, opts, &bk end
+        def head(path, opts={}, &bk)    route 'HEAD',    path, opts, &bk end
+        def options(path, opts={}, &bk) route 'OPTIONS', path, opts, &bk end
+        def patch(path, opts={}, &bk)   route 'PATCH',   path, opts, &bk end
+
+        private
+
+        def route(verb, path, options={}, &block)
+          path, params = compile_path(path)
+
+          return if route_exists?(verb, path)
+
+          builder = Rack::Builder.new(SerializeResponse.new)
+          builder.use(Rack::Head)
+          builder.use(UserLookup)
+          builder.use(AuthenticationLookup)
+          builder.use(AuthenticationVerification)
+          builder.use(AuthenticationFinalize)
+          builder.use(ExtractParams, path, params)
+          builder.use(Authorization)
+          block.call(builder)
+          builder.use(CachingHeaders)
+
+          routes.add_route(builder.to_app, :request_method => verb, :path_info => path)
+          routes.rehash
+        end
+
+        def route_exists?(verb, path)
+          @added_routes ||= []
+          return true if @added_routes.include?("#{verb}#{path}")
+          @added_routes << "#{verb}#{path}"
+          false
+        end
+
+        def compile_path(path)
+          keys = []
+          if path.respond_to? :to_str
+            ignore = ""
+            pattern = path.to_str.gsub(/[^\?\%\\\/\:\*\w]/) do |c|
+              ignore << escaped(c).join if c.match(/[\.@]/)
+              encoded(c)
+            end
+            pattern.gsub!(/((:\w+)|\*)/) do |match|
+              if match == "*"
+                keys << 'splat'
+                "(.*?)"
+              else
+                keys << $2[1..-1]
+                "([^#{ignore}/?#]+)"
+              end
+            end
+            [/\A#{pattern}\z/, keys]
+          elsif path.respond_to?(:keys) && path.respond_to?(:match)
+            [path, path.keys]
+          elsif path.respond_to?(:names) && path.respond_to?(:match)
+            [path, path.names]
+          elsif path.respond_to? :match
+            [path, keys]
+          else
+            raise TypeError, path
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tentd/api/router/caching_headers.rb

@@ -0,0 +1,49 @@
+require 'time'
+
+module TentD
+  class API
+    module Router
+      class CachingHeaders
+        def initialize(app)
+          @app = app
+        end
+
+        def call(env)
+          return @app.call(env) unless %w(GET HEAD).include?(env['REQUEST_METHOD'])
+          last_modified_at = last_modified(env.response)
+          if_modified_since = env['HTTP_IF_MODIFIED_SINCE']
+          if if_modified_since && Time.httpdate(if_modified_since) >= last_modified_at
+            return [304, {}, nil]
+          end
+          status, headers, body = @app.call(env)
+          headers['Last-Modified'] ||= last_modified_at.httpdate if last_modified_at
+          headers['Cache-Control'] ||= cache_control(env.response) if cache_control(env.response)
+          [status, headers, body]
+        end
+
+        private
+
+        def last_modified(object)
+          if object.respond_to?(:updated_at)
+            object.updated_at
+          elsif object.kind_of?(Enumerable) && object.first.respond_to?(:updated_at)
+            object.map { |o| o.updated_at }.sort.last
+          end
+        end
+
+        def cache_control(object)
+          if object.respond_to?(:public) || object.respond_to?(:permissions)
+            public?(object) ? 'public' : 'private'
+          elsif object.kind_of?(Enumerable) && (object.first.respond_to?(:public) || object.first.kind_of?(Hash) && object.first['permissions'])
+            object.map { |o| public?(o) }.uniq == [true] ? 'public' : 'private'
+          end
+        end
+
+        def public?(object)
+          object.respond_to?(:public) && object.public ||
+          object.kind_of?(Hash) && (object['public'] || object['permissions'] && object['permissions']['public'])
+        end
+      end
+    end
+  end
+end

data/lib/tentd/api/router/extract_params.rb

@@ -0,0 +1,88 @@
+module TentD
+  class API
+    module Router
+      class ExtractParams
+        attr_accessor :pattern, :keys
+
+        def initialize(app, pattern, keys)
+          @app, @pattern, @keys = app, pattern, keys
+        end
+
+        def call(env)
+          add_request(env)
+          extract_params(env)
+          env['tent.entity'] ||= ENV['TENT_ENTITY']
+          @app.call(env)
+        end
+
+        private
+
+        def add_request(env)
+          env['request'] = Rack::Request.new(env)
+        end
+
+        def extract_params(env)
+          route = env[Rack::Mount::Prefix::KEY]
+          route = '/' if route.empty?
+          return unless match = pattern.match(route)
+          values = match.captures.to_a.map { |v| URI.decode_www_form_component(v) if v }
+
+          params = env['request'].params.dup
+
+          if values.any?
+            params.merge!('captures' => values)
+            keys.zip(values) { |k,v| Array === params[k] ? params[k] << v : params[k] = v if v }
+          end
+
+          begin
+            if env['CONTENT_TYPE'] =~ /\bjson\Z/
+              params['data'] = env['data'] || JSON.parse(env['rack.input'].read)
+            elsif env['CONTENT_TYPE'] =~ /\Amultipart/
+              key, data = params.find { |k,p| p[:type] == MEDIA_TYPE }
+              params.delete(key)
+              params['data'] = JSON.parse(data[:tempfile].read)
+              params['attachments'] = get_attachments(params)
+            end
+          rescue JSON::ParserError
+          end
+
+          env['params'] = indifferent_params(params)
+        end
+
+        def get_attachments(params)
+          params.inject([]) { |a,(key,value)|
+            if attachment?(value)
+              a << value.merge(:name => key)
+            elsif value.kind_of?(Hash)
+              a += value.select { |k,v| attachment?(v) }.map { |k,v| v.merge(:name => key) }
+            end
+            a
+          }
+        end
+
+        def attachment?(v)
+          v.kind_of?(Hash) && v[:tempfile].kind_of?(Tempfile)
+        end
+
+        # Enable string or symbol key access to the nested params hash.
+        def indifferent_params(object)
+          case object
+          when Hash
+            new_hash = indifferent_hash
+            object.each { |key, value| new_hash[key] = indifferent_params(value) }
+            new_hash
+          when Array
+            object.map { |item| indifferent_params(item) }
+          else
+            object
+          end
+        end
+
+        # Creates a Hash with indifferent access.
+        def indifferent_hash
+          Hash.new {|hash,key| hash[key.to_s] if Symbol === key }
+        end
+      end
+    end
+  end
+end

data/lib/tentd/api/router/serialize_response.rb

@@ -0,0 +1,38 @@
+require 'json'
+
+module TentD
+  class API
+    module Router
+      class SerializeResponse
+        def call(env)
+          response = if env.response
+            env.response.kind_of?(String) ? env.response : env.response.to_json(serialization_options(env))
+          end
+          status = env['response.status'] || (response ? 200 : 404)
+          headers = if env['response.type'] || status == 200 && response && !response.empty?
+                      { 'Content-Type' => env['response.type'] || MEDIA_TYPE } 
+                    else
+                      {}
+                    end
+          headers.merge!('Access-Control-Allow-Origin' => '*') if env['HTTP_ORIGIN']
+          [status, headers, [response.to_s]]
+        end
+
+        private
+
+        def serialization_options(env)
+          {
+            :app => env.current_auth.kind_of?(Model::AppAuthorization),
+            :authorization_token => env.authorized_scopes.include?(:read_apps),
+            :permissions => env.authorized_scopes.include?(:read_permissions),
+            :groups => env.authorized_scopes.include?(:read_groups),
+            :mac => env.authorized_scopes.include?(:read_secrets),
+            :self => env.authorized_scopes.include?(:self),
+            :auth_token => env.authorized_scopes.include?(:authorization_token),
+            :view => env.params.view
+          }
+        end
+      end
+    end
+  end
+end

data/lib/tentd/api/user_lookup.rb

@@ -0,0 +1,10 @@
+module TentD
+  class API
+    class UserLookup < Middleware
+      def action(env)
+        Model::User.current ||= Model::User.first_or_create
+        env
+      end
+    end
+  end
+end

data/lib/tentd/core_ext/hash/slice.rb

@@ -0,0 +1,29 @@
+# Taken from rails
+class Hash
+  # Slice a hash to include only the given keys. This is useful for
+  # limiting an options hash to valid keys before passing to a method:
+  #
+  #   def search(criteria = {})
+  #     assert_valid_keys(:mass, :velocity, :time)
+  #   end
+  #
+  #   search(options.slice(:mass, :velocity, :time))
+  #
+  # If you have an array of keys you want to limit to, you should splat them:
+  #
+  #   valid_keys = [:mass, :velocity, :time]
+  #   search(options.slice(*valid_keys))
+  def slice(*keys)
+    keys.each_with_object(self.class.new) { |k, hash| hash[k] = self[k] if has_key?(k) }
+  end
+
+  # Replaces the hash with only the given keys.
+  # Returns a hash containing the removed key/value pairs.
+  #   {:a => 1, :b => 2, :c => 3, :d => 4}.slice!(:a, :b) # => {:c => 3, :d => 4}
+  def slice!(*keys)
+    omit = slice(*self.keys - keys)
+    hash = slice(*keys)
+    replace(hash)
+    omit
+  end
+end

data/lib/tentd/datamapper/array_property.rb

@@ -0,0 +1,23 @@
+module DataMapper
+  class Property
+    # Implements flat postgres string arrays
+    class Array < DataMapper::Property::Text
+      def custom?
+        true
+      end
+
+      def load(value)
+        return value if value.kind_of? ::Array
+        value[1..-2].split(',').map { |v| v[0,1] == '"' ? v[1..-2] : v  } unless value.nil?
+      end
+
+      def dump(value)
+        "{#{value.map(&:to_s).map(&:inspect).join(',')}}" unless value.nil?
+      end
+
+      def typecast(value)
+        load(value)
+      end
+    end
+  end
+end