smooth 2.0.1 → 2.0.2

data/lib/smooth/documentation.rb

@@ -1,9 +1,6 @@
 module Smooth
   module Documentation
-
-    def self.included base
-      binding.pry
-
+    def self.included(base)
       base.class_eval do
         attr_accessor :_inline_description
 
@@ -15,7 +12,7 @@ module Smooth
       base.extend Smooth::Documentation
     end
 
-    def desc description, *args
+    def desc(description, *args)
       self._inline_description = {
         description: description,
         args: args
@@ -23,7 +20,7 @@ module Smooth
     end
 
     def inline_description
-      val = self._inline_description && self._inline_description.dup
+      val = _inline_description && _inline_description.dup
       self._inline_description = nil
       val
     end

data/lib/smooth/dsl.rb

@@ -1,36 +1 @@
-module Smooth
-  module Dsl
-    # Creates or opens an API definition
-    def api name, *args, &block
-      Smooth.current_api_name = name
-
-      instance = Smooth.fetch_api(name) do |key|
-        options = args.dup.extract_options!
-
-        Smooth::Api.new(name, options).tap do |obj|
-          obj.instance_eval(&block) if block_given?
-        end
-      end
-
-      instance
-    end
-
-    # Creates or opens a resource definition
-    def resource name, *args, &block
-      options = args.extract_options!
-
-      api = case
-        when options[:api].is_a?(Symbol) || options[:api].is_a?(String)
-          Smooth.fetch_api(options[:api])
-        when options[:api].is_a?(Smooth::Api)
-          options[:api]
-        else
-          Smooth.current_api
-      end
-
-      api.resource(name, options, &block)
-    end
-  end
-end
-
-extend(Smooth::Dsl)
+extend(Smooth::DslAdapter)

data/lib/smooth/dsl_adapter.rb

@@ -0,0 +1,34 @@
+module Smooth
+  module DslAdapter
+    # Creates or opens an API definition
+    def api(name, *args, &block)
+      Smooth.current_api_name = name
+
+      config_block = block_given?
+
+      instance = Smooth.fetch_api(name) do |_key|
+        options = args.dup.extract_options!
+
+        Smooth::Api.new(name, options)
+      end
+
+      instance.tap { |obj| obj.instance_eval(&block) if config_block }
+    end
+
+    # Creates or opens a resource definition
+    def resource(name, *args, &block)
+      options = args.extract_options!
+
+      api = case
+        when options[:api].is_a?(Symbol) || options[:api].is_a?(String)
+          Smooth.fetch_api(options[:api])
+        when options[:api].is_a?(Smooth::Api)
+          options[:api]
+        else
+          Smooth.current_api
+      end
+
+      api.resource(name, options, &block)
+    end
+  end
+end

data/lib/smooth/event.rb

@@ -1,6 +1,8 @@
+require 'smooth/event/relay'
+require 'smooth/event/proxy'
+
 module Smooth
   class Event < ActiveSupport::Notifications::Event
-
     def self.provider
       ActiveSupport::Notifications
     end
@@ -11,13 +13,15 @@ module Smooth
     end
 
     module Adapter
-      def track_event *args, &block
+      def track_event(*args, &_block)
         Smooth::Event.provider.send(:instrument, *args)
       end
 
-      def subscribe_to event_name, &block
+      def subscribe_to(event_name, aggregator = nil, &block)
         Smooth::Event.provider.subscribe(event_name) do |*args|
-          block.call(Smooth::Event.new(*args), event_name)
+          event = Smooth::Event.new(*args)
+          aggregator << event if aggregator.respond_to?(:<<)
+          block.call(event, event_name) if block.respond_to?(:call)
         end
       end
     end

data/lib/smooth/event/proxy.rb

@@ -0,0 +1,9 @@
+class Smooth::Event::Proxy
+  def self.on(*args, &block)
+    Smooth::Event.send(:subscribe_to, *args, &block)
+  end
+
+  def self.trigger(*args, &block)
+    Smooth::Event.send(:track_event, *args, &block)
+  end
+end

data/lib/smooth/event/relay.rb

@@ -0,0 +1,38 @@
+# The Smooth::Event::Relay listens for events on any Smooth::Event notifications channel
+# It takes the event, performs some optional processing on it, and then relays information
+# about that event to some other service. For example, a websocket or another event tracking api.
+module Smooth
+  class Event < ActiveSupport::Notifications::Event
+    class Relay
+      attr_reader :event_name,
+                  :options,
+                  :system
+
+      def initialize(event_name, options = {})
+        @event_name = event_name
+        @options    = options
+        @system     = options.fetch(:system, Smooth::Event)
+
+        enable
+      end
+
+      def relay(_event, _event_name = nil)
+        # IMPLEMENT IN YOUR OWN CLASS
+        fail NotImplementedError
+      end
+
+      def process(event, event_name = nil)
+        [event, event_name]
+      end
+
+      def enable
+        @subscriber ||= system.subscribe_to(event_name, &method(:process_and_relay))
+      end
+
+      def process_and_relay(event, event_name = nil)
+        event, event_name = process(event, event_name)
+        relay(event, event_name)
+      end
+    end
+  end
+end

data/lib/smooth/example.rb

@@ -1,6 +1,6 @@
 module Smooth
   class Example
-    def self.configure example_description, options, resource=nil
+    def self.configure(_example_description, _options, _resource = nil)
     end
   end
 end

data/lib/smooth/ext/core.rb

@@ -3,3 +3,19 @@ class Hash
     Hashie::Mash.new(dup)
   end
 end
+
+class NilClass
+  def empty?
+    true
+  end
+end
+
+class String
+  def empty?
+    length == 0
+  end
+
+  def self.random_token(length = 12)
+    rand(36**36).to_s(36).slice(0, length)
+  end
+end

data/lib/smooth/model_adapter.rb

@@ -0,0 +1,31 @@
+module Smooth
+  module ModelAdapter
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    def query(current_user, params = {})
+      self.class.smooth_resource.fetch(:query, :default)
+        .as(current_user)
+        .run(params)
+    end
+
+    module ClassMethods
+      def acts_smooth(_options = {}, &block)
+        @smooth_resource ||= begin
+                               resource_name = to_s.split('::').last.to_s.pluralize
+                               Smooth.resource(resource_name, model: self, &block)
+                             end
+      end
+
+      # Because it depends how you feel.
+      def acts_real_smooth(options = {}, &block)
+        acts_smooth(options, &block)
+      end
+
+      def smooth_resource
+        @smooth_resource || acts_as_smooth
+      end
+    end
+  end
+end

data/lib/smooth/query.rb

@@ -1,15 +1,80 @@
 module Smooth
-  class Query
+  class Query < Smooth::Command
     include Smooth::Documentation
 
-    class_attribute :query_config
-    self.query_config = Hashie::Mash.new(base:{})
+    # To customize the filtering behavior of the query
+    # you can supply your own execute method body. The
+    # execute method is expected to mutate the value of the
+    # `self.scope` or @scope instance variable and to return
+    # something which can be serialized as JSON using the
+    # Smooth::Serializer
+    def execute
+      apply_filters
+      scope
+    end
+
+    def apply_filters
+      params.each(&method(:apply_filter))
+
+      if raw_inputs['ids']
+        ids = raw_inputs['ids']
+        ids = ids.split(',') if ids.is_a?(String)
+
+        self.scope = scope.where(id: Array(ids))
+      end
+    end
+
+    def validate
+      true
+    end
+
+    protected
+
+    def operator_for(filter)
+      specific = interface_for(filter).options.operator
+      return specific if specific
+      :eq
+    end
+
+    def operator_and_type_for(filter)
+      [operator_for(filter), interface_for(filter).type]
+    end
+
+    def column_for(key)
+      interface_for(key).options.column || key
+    end
+
+    def apply_filter(*parts)
+      key, value = parts.flatten
+
+      operator = operator_for(key)
+
+      value = "%#{value}%" if operator == :like
+      value = "#{value}%" if operator == :ends_with
+      value = "%#{value}" if operator == :begins_with
+
+      operator = :matches if operator == :like
+
+      column = column_for(key)
+      condition = arel_table[column].send(operator, value)
+
+      self.scope = scope.merge(scope.where(condition))
+    end
+
+    def arel_table
+      model_class.arel_table
+    end
 
-    def self.configure options, resource=nil
+    class_attribute :query_config,
+                    :parent_resource
+
+    self.query_config = Hashie::Mash.new(base: {})
+
+    def self.configure(dsl_config_object, resource = nil)
       resource ||= Smooth.current_resource
-      klass = define_or_open(options, resource)
+      klass = define_or_open(dsl_config_object, resource)
 
-      Array(options.blocks).each do |blk|
+      Array(dsl_config_object.blocks).each do |blk|
         klass.class_eval(&blk)
       end
 
@@ -21,28 +86,47 @@ module Smooth
       base          = Smooth.query
 
       name = options.name
-      name = nil if name == "Default"
+      name = nil if name == 'Default'
+
+      klass = "#{ resource.model_class }#{ name }".singularize + 'Query'
 
-      klass = "#{ resource_name }#{ name }".singularize + "Query"
+      klass = klass.gsub(/\s+/, '')
+
+      apply_options = lambda do |k|
+        k.model_class     ||= resource.model_class if resource.model_class
+
+        k.resource_name   = resource.name.to_s if k.resource_name.empty?
+        k.command_action  = 'query' if k.command_action.empty?
+        k.belongs_to_resource(resource)
+      end
 
       if query_klass = Object.const_get(klass) rescue nil
-        return query_klass
+        return query_klass.tap(&apply_options)
       end
 
-      Object.const_set(klass, Class.new(base))
+      begin
+        Object.const_set(klass, Class.new(base)).tap(&apply_options)
+      rescue
+        binding.pry
+      end
     end
 
-    def self.start_from *args, &block
+    def self.start_from(*args, &_block)
       options = args.extract_options!
       config.start_from = options
     end
 
-    def self.params *args, &block
+    def params
+      inputs
+    end
+
+    def self.params(*args, &block)
       options = args.extract_options!
       config.params = options
+      send(:optional, *args, &block)
     end
 
-    def self.role name, &block
+    def self.role(name, &block)
       @current_config = name
       instance_eval(&block) if block_given?
     end
@@ -58,5 +142,51 @@ module Smooth
       val
     end
 
+    def self.respond_to_find_request(request_object, _options = {})
+      outcome = as(request_object.user).run(request_object.params)
+
+      Smooth::Response.new(nil).tap do |response|
+        response.command_action = :find
+        response.event_namespace = event_namespace
+        response.request_headers = request_object.headers
+
+        if outcome.success?
+          response.object = outcome.result.find(request_object.params[:id])
+          response.success = true
+          response.serializer = find_serializer_for(request_object)
+        end
+      end
+    end
+
+    def self.response_class
+      Smooth::Query::Response
+    end
+
+    class Response < Smooth::Response
+      def serializer
+        if command_action.to_sym == :find
+          @serializer
+        else
+          Smooth::ArraySerializer
+        end
+      end
+
+      def options
+        @serializer_options.tap do |o|
+          o[:each_serializer] = @serializer unless command_action == :find
+          o[:scope] = current_user
+        end
+      end
+
+      def object
+        return @object if @object
+
+        if command_action.to_sym == :find
+          outcome.result
+        elsif success? && command_action.to_sym == :query
+          outcome.result.to_a
+        end
+      end
+    end
   end
 end

data/lib/smooth/resource.rb

@@ -1,47 +1,137 @@
+require 'smooth/resource/templating'
+
 module Smooth
   class Resource
     include Smooth::Documentation
+    include Smooth::Resource::Templating
 
     attr_accessor :resource_name,
-                  :api_name
+                  :api_name,
+                  :model_class,
+                  :group_description,
+                  :description
 
     # These store the configuration values for the various
     # objects belonging to the resource.
-    attr_reader  :_queries,
-                 :_commands,
-                 :_serializers,
-                 :_routes,
-                 :_examples
+    attr_reader :_queries,
+                :_commands,
+                :_serializers,
+                :_routes,
+                :_examples,
+                :object_descriptions
+
+    def initialize(resource_name, options = {}, &block)
+      @resource_name  = resource_name
+      @options        = options
+
+      @model_class    = options.fetch(:model, nil)
+
+      @_serializers   = {}.to_mash
+      @_commands      = {}.to_mash
+      @_queries       = {}.to_mash
+      @_routes        = {}.to_mash
+      @_examples      = {}.to_mash
+
+      @object_descriptions = {
+        commands: {},
+        queries: {},
+        serializers: {},
+        routes: {},
+        examples: {}
+      }
+
+      @loaded         = false
+
+      instance_eval(&block) if block_given?
 
-    def initialize(resource_name, options={}, &block)
-      @resource_name = resource_name
-      @options = options
+      load!
+    end
 
-      @_serializers = {}.to_mash
-      @_commands    = {}.to_mash
-      @_queries     = {}.to_mash
-      @_routes      = {}.to_mash
-      @_examples    = {}.to_mash
+    # The Smooth Resources are capable of exposing information
+    # about their configuration, which makes auto generating documentation
+    # for their API very easy, but this can also be used to generate
+    # client side models or control form / report builder interfaces.
+    def interface_documentation
+      resource = self
 
-      @loaded       = false
+      @interface ||= begin
+                       base = {
+                         routes: (router.interface_documentation rescue {})
+                       }
+
+                       resource.object_descriptions.keys.reduce(base) do |memo, type|
+                         memo.tap do
+                           bucket = memo[type] ||= {}
+                           resource.send("available_#{ type }").each do |object_name|
+                             docs = resource.expanded_documentation_for(type, object_name)
+                             bucket[object_name] = docs
+                           end
+                         end
+                       end
+                     end.to_mash
+    end
 
-      instance_eval(&block) if block_given?
+    # Resource groups allow for easier organization of the
+    # documentation and things of that nature.
+    def part_of_the(group_description)
+      @group_description = group_description
+    end
 
-      load!
+    def available_commands
+      _commands.keys
+    end
+
+    def available_queries
+      _queries.keys
+    end
+
+    def available_serializers
+      _serializers.keys
+    end
+
+    # SHORT CIRCUIT
+    def available_routes
+      []
+    end
+
+    def available_examples
+      _examples.keys
+    end
+
+    def model_class
+      @model_class || (resource_name.singularize.constantize rescue nil)
     end
 
     def name
       resource_name
     end
 
-    def fetch_config object_type, object_key
+    def has_many(*args)
+      model_class.send(:has_many, *args)
+    end
+
+    def belongs_to(*args)
+      model_class.send(:belongs_to, *args)
+    end
+
+    def has_one(*args)
+      model_class.send(:has_one, *args)
+    end
+
+    def has_and_belongs_to_many(*args)
+      model_class.send(:has_and_belongs_to_many, *args)
+    end
+
+    def fetch_config(object_type, object_key)
       source = send("_#{ object_type }s") rescue nil
-      source && source.fetch(object_key.to_sym)
+      source = @_queries if object_type.to_sym == :query
+      source && source.fetch(object_key.to_s.downcase.to_sym)
     end
 
-    def fetch object_type, object_key
+    def fetch(object_type, object_key)
       source = instance_variable_get("@#{ object_type }s") rescue nil
-      source && source.fetch(object_key.to_sym)
+      source = @queries if object_type.to_sym == :query
+      source && source.fetch(object_key.to_s.downcase)
     end
 
     def loaded?
@@ -60,82 +150,163 @@ module Smooth
       Smooth.fetch_api(api_name || :default)
     end
 
-    def apply_options *opts
+    def apply_options(*opts)
       @options.send(:merge!, *opts)
     end
 
-    def serializer serializer_name="Default", *args, &block
+    def describe_object(object_type, object_name, with_value = {})
+      bucket = documentation_for(object_type, object_name)
+
+      with_value = { description: with_value } if with_value.is_a?(String)
+
+      bucket[:description] = with_value.fetch(:description, with_value['description'])
+      bucket[:description_args] = with_value.fetch(:args, [])
+    end
+
+    def documentation_for(object_type, object_name)
+      object_descriptions[object_type.to_s.pluralize.to_sym][object_name.to_sym] ||= {}
+    end
+
+    def expanded_documentation_for(object_type, object_name)
+      base = documentation_for(object_type, object_name)
+      klass = object_class_for(object_type, object_name)
+
+      base.merge!(class: klass.to_s, interface: klass && klass.interface_documentation)
+    end
+
+    def object_class_for(object_type, object_name)
+      fetch(object_type.to_s.singularize.to_sym, object_name.to_sym)
+    rescue => e
+      binding.pry
+    end
+
+    def serializer(serializer_name = 'Default', *args, &block)
       if args.empty? && !block_given? && exists = fetch(:serializer, serializer_name)
         return exists
       end
 
       options = args.extract_options!
 
-      description = options.fetch(:description) do
-        args.first || inline_description
-      end
+      provided_description = options.fetch(:description, inline_description)
 
-      config = _serializers[serializer_name.to_sym] ||= Hashie::Mash.new(options: {}, name: serializer_name, blocks: [block].compact)
-      config.description = description unless description.nil?
+      describe_object(:serializer, serializer_name.downcase, provided_description) unless provided_description.empty?
 
-      config
+      specified_class = args.first
+      specified_class = specified_class.constantize if specified_class.is_a?(String)
+      specified_class = nil if specified_class && !(specified_class <= Smooth.config.serializer_class)
+
+      config = _serializers[serializer_name.downcase.to_sym] ||= Hashie::Mash.new(options: {}, name: serializer_name, blocks: [block].compact, class: specified_class)
+      config.description = provided_description unless provided_description.nil?
     end
 
-    def command command_name, *args, &block
+    def command(command_name, *args, &block)
       if args.empty? && !block_given? && exists = fetch(:command, command_name)
         return exists
       end
 
       options = args.extract_options!
 
-      description = options.fetch(:description) do
-        args.first || inline_description
-      end
+      provided_description = options.fetch(:description, inline_description)
+
+      describe_object(:command, command_name.downcase, provided_description) unless provided_description.empty?
 
-      config = _commands[command_name.to_sym] ||= Hashie::Mash.new(options: {}, name: command_name, blocks: [block].compact)
+      specified_class = args.first
+      specified_class = (specified_class.constantize rescue nil) if specified_class.is_a?(String)
+      specified_class = nil if specified_class && !(specified_class <= Smooth.config.command_class)
+
+      config = _commands[command_name.to_sym] ||= Hashie::Mash.new(options: {}, name: command_name, blocks: [block].compact, class: specified_class)
 
       config.options.merge!(options)
-      config.description = description unless description.nil?
+      config.description = provided_description unless provided_description.nil?
 
       config
     end
 
-    def query query_name="Default", *args, &block
+    def query(query_name = 'Default', *args, &block)
       if args.empty? && !block_given? && exists = fetch(:query, query_name)
         return exists
       end
 
       options = args.extract_options!
 
-      description = options.fetch(:description) do
-        args.first || inline_description
-      end
+      provided_description = options.fetch(:description, inline_description)
 
-      config = _queries[query_name.to_sym] ||= Hashie::Mash.new(options: {}, name: query_name, blocks: [block].compact)
+      describe_object(:query, query_name.downcase, provided_description) unless provided_description.empty?
+
+      specified_class = args.first
+      specified_class = (specified_class.constantize rescue nil) if specified_class.is_a?(String)
+      specified_class = nil if specified_class && !(specified_class <= Smooth.config.query_class)
+
+      config = _queries[query_name.downcase.to_sym] ||= Hashie::Mash.new(options: {}, name: query_name, blocks: [block].compact, class: specified_class)
       config.options.merge!(options)
-      config.description = description unless description.nil?
+      config.description = provided_description unless provided_description.nil?
 
       config
     end
 
-    def routes &block
-      return @routes if !block_given?
+    def routes(options = {}, &block)
+      return @router unless block_given?
+
+      @router ||= Smooth::Resource::Router.new(self, options).tap do |router|
+        router.instance_eval(&block)
+        router.build_methods_table
+      end
+    end
+
+    def model(&block)
+      model_class.instance_eval(&block)
+    end
+
+    def scope(*args, &block)
+      model_class.send(:scope, *args, &block)
+    end
+
+    def router
+      @router || routes
+    end
+
+    def route_table
+      router.route_table
+    end
+
+    def expand_routes(from_attributes = {})
+      router.expand_routes(from_attributes)
     end
 
-    def examples options={}, &block
+    def examples(options = {}, &_block)
       if options.empty? && !block_given?
         return @examples
       end
     end
 
+    def serializer_class(reference = :default)
+      @serializers.fetch(reference, serializer_classes.first)
+    end
+
+    def query_class(reference = :default)
+      @queries.fetch(reference, query_classes.first)
+    end
+
+    def serializer_classes
+      @serializers && @serializers.values
+    end
+
+    def query_classes
+      @queries && @queries.values
+    end
+
+    def command_classes
+      @commands && @commands.values
+    end
+
     protected
 
     def configure_commands
       resource = self
 
-      @commands = _commands.inject({}.to_mash) do |memo, p|
+      @commands = _commands.reduce({}.to_mash) do |memo, p|
         ref, cfg = p
-        memo[cfg.name] = Smooth::Command.configure(cfg, resource)
+        memo[cfg.name.downcase] = Smooth::Command.configure(cfg, resource)
         memo
       end
     end
@@ -143,19 +314,22 @@ module Smooth
     def configure_serializers
       resource = self
 
-      @serializers = _serializers.inject({}.to_mash) do |memo, p|
-        ref, cfg = p
-        memo[cfg.name] = Smooth::Serializer.configure(cfg, resource)
-        memo
+      @serializers = _serializers.reduce({}.to_mash) do |memo, p|
+        memo.tap do
+          ref, cfg = p
+          serializer = memo[cfg.name.downcase] = Smooth::Serializer.configure(cfg, resource)
+
+          serializer.return_ids_for_relationships! if Smooth.config.embed_relationships_as == :ids
+        end
       end
     end
 
     def configure_queries
       resource = self
 
-      @queries = _queries.inject({}.to_mash) do |memo, p|
+      @queries = _queries.reduce({}.to_mash) do |memo, p|
         ref, cfg = p
-        memo[cfg.name] = Smooth::Query.configure(cfg, resource)
+        memo[cfg.name.downcase] = Smooth::Query.configure(cfg, resource)
         memo
       end
     end
@@ -171,3 +345,4 @@ module Smooth
 end
 
 require 'smooth/resource/tracking'
+require 'smooth/resource/router'