smooth 2.0.1 → 2.0.2

data/lib/smooth/resource/router.rb

@@ -0,0 +1,217 @@
+module Smooth
+  class Resource
+    class Router
+      attr_reader :resource,
+                  :table,
+                  :descriptions,
+                  :rules
+
+      def initialize(resource, _options = {})
+        @resource = resource
+        @table = {}
+        @descriptions = {}
+        @rules = []
+      end
+
+      # I may be getting this in a convoluted way
+      # may be easier to build up naturally
+      def interface_documentation
+        descriptions.keys.reduce({}) do |memo, verb|
+          routes = descriptions[verb]
+          routes.each do |_|
+            pattern, description = _
+            memo["#{ verb.to_s.upcase } #{ pattern }"] = description
+          end
+
+          memo
+        end
+      end
+
+      def route_table
+        @route_table ||= route_patterns_table.reduce({}) do |memo, p|
+          route_name, details = p
+          memo[route_name] = details[:pattern]
+          memo
+        end
+      end
+
+      def expand_routes(from_attributes = {})
+        route_patterns_table.reduce({}) do |memo, p|
+          route_name, details = p
+          memo[route_name] = Smooth.util.expand_url_template(details[:template], from_attributes)
+          memo
+        end
+      end
+
+      def route_patterns_table
+        return @route_patterns_table if @route_patterns_table
+
+        @route_patterns_table = rules.flatten.compact.reduce({}) do |memo, rule|
+          memo.tap do
+            name = rule[:name]
+            pattern = rule[:pattern]
+            template = rule[:template]
+
+            memo[name] = {
+              pattern: pattern,
+              template: template,
+              variables: Array(template.variables)
+            }
+          end
+        end
+      end
+
+      def patterns
+        rules.flatten.compact.map { |r| r.fetch(:pattern) }
+      end
+
+      def uri_templates
+        rules.flatten.compact.map { |r| r.fetch(:template) }
+      end
+
+      def apply_to(sinatra)
+        router = self
+
+        user_finder = resource.api.method(:lookup_current_user).to_proc
+        policy_finder = resource.api.method(:lookup_policy).to_proc
+
+        router.rules.each do |_|
+          options, _ = _
+
+          handler = methods_table.method(options[:name])
+
+          sinatra.send options[:method], options[:pattern] do |*args|
+            begin
+              request = {
+                headers: headers,
+                params: params,
+                user: user_finder.call(params, headers),
+                policy: policy_finder.call(params, headers),
+                args: args
+              }
+            rescue => exception
+              halt 500, {}, { error: exception.message, backtrace: exception.backtrace, stage: 'request' }.to_json
+            end
+
+            begin
+              response = handler.call(request.to_mash)
+
+              body response.body
+              headers response.headers
+              status response.status
+            rescue => exception
+              halt 500, {}, { error: exception.message, backtrace: exception.backtrace, stage: 'response' }.to_json
+            end
+          end
+        end
+      end
+
+      def build_methods_table
+        router = self
+
+        @methods_table_class = Class.new do
+
+          k = self
+
+          router.rules.each do |_|
+            options, block = _
+            method_name   = options.fetch(:name)
+            k.send :define_method, method_name, (block || router.lookup_handler_for(options[:method], options[:to]))
+          end
+        end
+      end
+
+      def counter
+        @counter ||= 0
+        @counter += 1
+      end
+
+      def methods_table
+        @methods_table ||= (@methods_table_class || build_methods_table).new
+      end
+
+      def desc(description, *_args)
+        descriptions[:current] = description
+      end
+
+      Verbs = {
+        get: :get,
+        show: :get,
+        put: :put,
+        patch: :put,
+        create: :post,
+        delete: :delete,
+        destroy: :destroy,
+        options: :options,
+        post: :post
+      }
+
+      def method_missing(meth, *args, &block)
+        if Verbs.keys.include?(meth.to_sym)
+          pattern = args.shift
+          define_route(meth, pattern, *args, &block)
+        else
+          super
+        end
+      end
+
+      def define_route(request_method, route_pattern, *args, &block)
+        request_method = Verbs.fetch(request_method.to_sym, :get)
+        bucket = table[request_method] ||= {}
+        options = args.extract_options!
+
+        name = options.fetch(:as, "#{ request_method }_#{ counter }")
+
+        describe_route(request_method, route_pattern)
+
+        rules << bucket[route_pattern] = [
+          options.merge(name: name, method: request_method, args: args, pattern: route_pattern, template: Smooth.util.uri_template(route_pattern)),
+          block
+        ]
+      end
+
+      def describe_route(request_method, route_pattern)
+        documentation = descriptions[request_method] ||= {}
+
+        if description = descriptions[:current]
+          documentation[route_pattern] = description
+          descriptions.delete(:current)
+        end
+      end
+
+      # Allows for a configuration syntax like
+      #
+      # routes do
+      #   get "/books", :to => :query
+      # end
+      #
+      # the lookup_handler_for method will attempt to
+      # discern which object is best suited to handle the
+      # request based on the http verb and the signifier
+      def lookup_handler_for(method, signifier)
+        method = method.to_sym
+        signifier = signifier.to_sym
+
+        resource = self.resource
+
+        case
+
+        when method == :get && signifier == :query
+          ->(req) { resource.fetch(:query, :default).respond_to_request(req) }
+
+        when (method == :show || method == :get) && signifier == :show
+          ->(req) { resource.fetch(:query, :default).respond_to_find_request(req) }
+
+        when method == :get
+          ->(req) { resource.fetch(:query, signifier).respond_to_request(req) }
+
+        # Mutation Methods
+        when method == :put || method == :post || method == :delete
+          ->(req) { resource.fetch(:command, signifier).respond_to_request(req) }
+        else
+          ->(req) { Smooth::ErrorResponse.new('Unable to find matching route', req) }
+        end
+      end
+    end
+  end
+end

data/lib/smooth/resource/templating.rb

@@ -0,0 +1,62 @@
+module Smooth
+  class Resource
+    module Templating
+      FakerGroups = %w(
+        Address Lorem Color Company Food HipterIpsum Internet Job Name Movie PhoneNumber Product Unit Vehicle Venue Skill
+      )
+
+      def self.fakers
+        FakerGroups.flat_map do |group|
+          prefix = group.to_s.underscore.downcase
+          space = Faker.const_get(group.to_sym) rescue nil
+
+          if space && space.class == Module
+            (space.methods - Object.methods - [:k, :underscore]).map { |m| "#{prefix}.#{m}" }
+          end
+        end.compact.uniq
+      end
+
+      def create_from_template(name = nil, *args, &block)
+        if name.is_a?(Hash)
+          args.unshift(name)
+          name = @template_name
+        end
+        FactoryGirl.create(name || @template_name, *args, &block)
+      end
+
+      def build_from_template(name = nil, *args, &block)
+        if name.is_a?(Hash)
+          args.unshift(name)
+          name = @template_name
+        end
+
+        FactoryGirl.build(name || @template_name, *args, &block)
+      end
+
+      def template(name = nil, *args, &block)
+        options = args.extract_options!
+
+        if name.nil?
+          name = model_class.table_name.singularize.to_sym
+          @template_name ||= name
+        end
+
+        options[:class] ||= model_class
+
+        FactoryGirl.define do
+          factory(name.to_sym, options, &block)
+        end
+      end
+
+      def template_registered?(name = nil)
+        name ||= model_class.table_name.singularize.to_sym
+        !!(FactoryGirl.factory_by_name(name) rescue nil)
+      end
+
+      # Just allows us to wrap template definitions
+      def templates(&block)
+        instance_eval(&block)
+      end
+    end
+  end
+end

data/lib/smooth/resource/tracking.rb

@@ -5,7 +5,7 @@ module Smooth
         @@resources ||= {}
       end
 
-      def current_resource= resource_object
+      def current_resource=(resource_object)
         @current_resource = resource_object.identifier
       end
 

data/lib/smooth/response.rb

@@ -0,0 +1,73 @@
+module Smooth
+  class Response
+    attr_reader :outcome, :serializer_options
+
+    attr_accessor :request_headers, :serializer, :event_namespace, :command_action, :success, :object, :serializer_klass, :current_user
+
+    def initialize(outcome, serializer_options = {})
+      @outcome = outcome
+      @serializer_options = serializer_options
+    end
+
+    def to_rack
+      [status, headers, [body]]
+    end
+
+    def headers
+      {
+        'Content-Type' => 'application/json'
+      }
+    end
+
+    def options
+      if success? && serializer
+        (@serializer_options || {}).merge(serializer: serializer, scope: current_user)
+      else
+        @serializer_options.merge(scope: current_user)
+      end
+    end
+
+    def body
+      serializer.new(object, options).to_json(options)
+    end
+
+    def object
+      @object || begin
+        if success?
+          outcome.result
+        else
+          outcome.errors.message
+        end
+      end
+    end
+
+    def success?
+      @success || (outcome && outcome.success?)
+    end
+
+    def status
+      case
+      when success?
+        200
+      else
+        400
+      end
+    end
+  end
+
+  class ErrorResponse < Response
+    def initialize(error_message, _request_object, *_args)
+      @error_message = error_message
+    end
+
+    def success?
+      false
+    end
+
+    def body
+      {
+        error: error_message
+      }
+    end
+  end
+end

data/lib/smooth/serializer.rb

@@ -3,12 +3,50 @@ module Smooth
     include Smooth::Documentation
 
     class_attribute :attribute_descriptions,
-                    :relationship_descriptions
+                    :relationship_descriptions,
+                    :resource_route_variables
 
     self.attribute_descriptions   = {}.to_mash
     self.relationship_descriptions = {}.to_mash
 
-    def self.method_added method_name
+    # WIP
+    # Need to determine how to access the serialized version
+    # as it exists in the context of the serializer instance
+    def expand_routes(*slice)
+      expanded = parent_resource.expand_routes(route_variables)
+
+      unless slice.empty?
+        expanded = expanded.send(:slice, *slice)
+      end
+
+      expanded.transform_keys do |key|
+        "#{ key }_url"
+      end
+    end
+
+    def route_variables
+      serializer = self
+
+      self.class.route_variables.reduce({}) do |memo, var|
+        value = case
+                when serializer.respond_to?(var)
+                  serializer.send(var)
+                when serializer.object.respond_to?(var)
+                  serializer.object.send(var)
+                else
+                  serializer.read_attribute_for_serialization(var)
+                end
+
+        memo[var] = value
+        memo
+      end
+    end
+
+    def self.route_variables
+      @resource_route_variables ||= parent_resource.router.route_patterns_table.map { |p| _, h = p; h[:variables] }.flatten.compact.uniq
+    end
+
+    def self.method_added(method_name)
       if documented = inline_description
         attribute_descriptions[method_name.to_sym] = documented
       end
@@ -22,7 +60,7 @@ module Smooth
       schema[:associations]
     end
 
-    def self.configure options, resource=nil
+    def self.configure(options, resource = nil)
       resource ||= Smooth.current_resource
       klass = define_or_open(options, resource)
 
@@ -38,22 +76,53 @@ module Smooth
       base          = Smooth.serializer
 
       name = options.name
-      name = nil if name == "Default"
+      name = nil if name == 'Default'
+
+      klass = "#{ resource.model_class }#{ name }".singularize + 'Serializer'
 
-      klass = "#{ resource_name }#{ name }".singularize + "Serializer"
+      klass = klass.gsub(/\s+/, '')
 
       if serializer_klass = Object.const_get(klass) rescue nil
         return serializer_klass
       end
 
-      Object.const_set(klass, Class.new(base))
+      parent_klass = Class.new(base)
+
+      parent_klass.belongs_to_resource(resource)
+
+      begin
+        Object.const_set(klass, parent_klass)
+      rescue => ex
+        puts ex.message
+        puts "Error setting #{ klass } #{ base }. klass is a #{ klass.class }"
+      end
+
+      parent_klass
     end
 
-    def self.documentation_for_attribute attribute
+    class_attribute :parent_resource
+
+    def parent_resource
+      self.class.parent_resource
+    end
+
+    def parent_api
+      self.class.parent_api
+    end
+
+    def self.belongs_to_resource(resource)
+      self.parent_resource = resource
+    end
+
+    def self.parent_api
+      parent_resource.api
+    end
+
+    def self.documentation_for_attribute(attribute)
       attribute_descriptions[attribute.to_sym]
     end
 
-    def self.documentation_for_association association
+    def self.documentation_for_association(association)
       relationship_descriptions[association.to_sym]
     end
 
@@ -61,7 +130,11 @@ module Smooth
       attribute_descriptions.merge(relationship_descriptions).to_mash
     end
 
-    def self.attribute attr, options={}
+    def self.interface_documentation
+      documentation
+    end
+
+    def self.attribute(attr, options = {})
       documented = inline_description
 
       if documented
@@ -71,7 +144,13 @@ module Smooth
       super
     end
 
-    def self.has_one attr, options={}
+    def self.computed(*args, &block)
+      property_name = args.first
+      send(:define_method, property_name, &block)
+      send(:attribute, *args)
+    end
+
+    def self.has_one(attr, options = {})
       documented = inline_description
 
       if documented
@@ -81,7 +160,7 @@ module Smooth
       super
     end
 
-    def self.has_many attr, options={}
+    def self.has_many(attr, options = {})
       documented = inline_description
 
       if documented
@@ -90,5 +169,17 @@ module Smooth
 
       super
     end
+
+    def self.return_ids_for_relationships!
+      @returns_ids_for_relationships = true
+      embed :ids
+    end
+
+    def self.returns_ids_for_relationships?
+      @returns_ids_for_relationships == true
+    end
+  end
+
+  class ArraySerializer < ActiveModel::ArraySerializer
   end
 end