smooth 2.0.1

data/lib/smooth/configuration.rb

@@ -0,0 +1,25 @@
+require 'singleton'
+
+module Smooth
+  class Configuration
+    include Singleton
+
+    cattr_accessor :query_class,
+                   :command_class,
+                   :serializer_class,
+                   :enable_events
+
+    @@query_class       = Smooth::Query
+    @@command_class     = Smooth::Command
+    @@serializer_class  = defined?(ApplicationSerializer) ? ApplicationSerializer : Smooth::Serializer
+    @@enable_events     = true
+
+    def enable_event_tracking?
+      !!@@enable_events
+    end
+
+    def self.method_missing meth, *args, &block
+      instance.send(meth, *args, &block)
+    end
+  end
+end

data/lib/smooth/documentation.rb

@@ -0,0 +1,31 @@
+module Smooth
+  module Documentation
+
+    def self.included base
+      binding.pry
+
+      base.class_eval do
+        attr_accessor :_inline_description
+
+        class << self
+          attr_accessor :_inline_description
+        end
+      end
+
+      base.extend Smooth::Documentation
+    end
+
+    def desc description, *args
+      self._inline_description = {
+        description: description,
+        args: args
+      }
+    end
+
+    def inline_description
+      val = self._inline_description && self._inline_description.dup
+      self._inline_description = nil
+      val
+    end
+  end
+end

data/lib/smooth/dsl.rb

@@ -0,0 +1,36 @@
+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)

data/lib/smooth/event.rb

@@ -0,0 +1,27 @@
+module Smooth
+  class Event < ActiveSupport::Notifications::Event
+
+    def self.provider
+      ActiveSupport::Notifications
+    end
+
+    def payload
+      hash = super
+      hash && hash.to_mash
+    end
+
+    module Adapter
+      def track_event *args, &block
+        Smooth::Event.provider.send(:instrument, *args)
+      end
+
+      def subscribe_to event_name, &block
+        Smooth::Event.provider.subscribe(event_name) do |*args|
+          block.call(Smooth::Event.new(*args), event_name)
+        end
+      end
+    end
+
+    extend Adapter
+  end
+end

data/lib/smooth/example.rb

@@ -0,0 +1,6 @@
+module Smooth
+  class Example
+    def self.configure example_description, options, resource=nil
+    end
+  end
+end

data/lib/smooth/ext/core.rb

@@ -0,0 +1,5 @@
+class Hash
+  def to_mash
+    Hashie::Mash.new(dup)
+  end
+end

data/lib/smooth/ext/mutations.rb

@@ -0,0 +1 @@
+Mutations.cache_constants = false

data/lib/smooth/query.rb

@@ -0,0 +1,62 @@
+module Smooth
+  class Query
+    include Smooth::Documentation
+
+    class_attribute :query_config
+    self.query_config = Hashie::Mash.new(base:{})
+
+    def self.configure options, resource=nil
+      resource ||= Smooth.current_resource
+      klass = define_or_open(options, resource)
+
+      Array(options.blocks).each do |blk|
+        klass.class_eval(&blk)
+      end
+
+      klass
+    end
+
+    def self.define_or_open(options, resource)
+      resource_name = resource.name
+      base          = Smooth.query
+
+      name = options.name
+      name = nil if name == "Default"
+
+      klass = "#{ resource_name }#{ name }".singularize + "Query"
+
+      if query_klass = Object.const_get(klass) rescue nil
+        return query_klass
+      end
+
+      Object.const_set(klass, Class.new(base))
+    end
+
+    def self.start_from *args, &block
+      options = args.extract_options!
+      config.start_from = options
+    end
+
+    def self.params *args, &block
+      options = args.extract_options!
+      config.params = options
+    end
+
+    def self.role name, &block
+      @current_config = name
+      instance_eval(&block) if block_given?
+    end
+
+    def self.config
+      val = query_config.send(@current_config || :base)
+
+      if val.nil?
+        val = query_config[@current_config] = {}
+        return config
+      end
+
+      val
+    end
+
+  end
+end

data/lib/smooth/resource.rb

@@ -0,0 +1,173 @@
+module Smooth
+  class Resource
+    include Smooth::Documentation
+
+    attr_accessor :resource_name,
+                  :api_name
+
+    # These store the configuration values for the various
+    # objects belonging to the resource.
+    attr_reader  :_queries,
+                 :_commands,
+                 :_serializers,
+                 :_routes,
+                 :_examples
+
+    def initialize(resource_name, options={}, &block)
+      @resource_name = resource_name
+      @options = options
+
+      @_serializers = {}.to_mash
+      @_commands    = {}.to_mash
+      @_queries     = {}.to_mash
+      @_routes      = {}.to_mash
+      @_examples    = {}.to_mash
+
+      @loaded       = false
+
+      instance_eval(&block) if block_given?
+
+      load!
+    end
+
+    def name
+      resource_name
+    end
+
+    def fetch_config object_type, object_key
+      source = send("_#{ object_type }s") rescue nil
+      source && source.fetch(object_key.to_sym)
+    end
+
+    def fetch object_type, object_key
+      source = instance_variable_get("@#{ object_type }s") rescue nil
+      source && source.fetch(object_key.to_sym)
+    end
+
+    def loaded?
+      !!@loaded
+    end
+
+    def load!
+      configure_commands
+      configure_serializers
+      configure_queries
+      configure_routes
+      configure_examples
+    end
+
+    def api
+      Smooth.fetch_api(api_name || :default)
+    end
+
+    def apply_options *opts
+      @options.send(:merge!, *opts)
+    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
+
+      config = _serializers[serializer_name.to_sym] ||= Hashie::Mash.new(options: {}, name: serializer_name, blocks: [block].compact)
+      config.description = description unless description.nil?
+
+      config
+    end
+
+    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
+
+      config = _commands[command_name.to_sym] ||= Hashie::Mash.new(options: {}, name: command_name, blocks: [block].compact)
+
+      config.options.merge!(options)
+      config.description = description unless description.nil?
+
+      config
+    end
+
+    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
+
+      config = _queries[query_name.to_sym] ||= Hashie::Mash.new(options: {}, name: query_name, blocks: [block].compact)
+      config.options.merge!(options)
+      config.description = description unless description.nil?
+
+      config
+    end
+
+    def routes &block
+      return @routes if !block_given?
+    end
+
+    def examples options={}, &block
+      if options.empty? && !block_given?
+        return @examples
+      end
+    end
+
+    protected
+
+    def configure_commands
+      resource = self
+
+      @commands = _commands.inject({}.to_mash) do |memo, p|
+        ref, cfg = p
+        memo[cfg.name] = Smooth::Command.configure(cfg, resource)
+        memo
+      end
+    end
+
+    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
+      end
+    end
+
+    def configure_queries
+      resource = self
+
+      @queries = _queries.inject({}.to_mash) do |memo, p|
+        ref, cfg = p
+        memo[cfg.name] = Smooth::Query.configure(cfg, resource)
+        memo
+      end
+    end
+
+    def configure_routes
+      @routes = {}
+    end
+
+    def configure_examples
+      @examples = {}
+    end
+  end
+end
+
+require 'smooth/resource/tracking'

data/lib/smooth/resource/tracking.rb

@@ -0,0 +1,17 @@
+module Smooth
+  class Resource
+    module Tracking
+      def resources
+        @@resources ||= {}
+      end
+
+      def current_resource= resource_object
+        @current_resource = resource_object.identifier
+      end
+
+      def current_resource
+        resources[@current_resource]
+      end
+    end
+  end
+end

data/lib/smooth/serializer.rb

@@ -0,0 +1,94 @@
+module Smooth
+  class Serializer < ActiveModel::Serializer
+    include Smooth::Documentation
+
+    class_attribute :attribute_descriptions,
+                    :relationship_descriptions
+
+    self.attribute_descriptions   = {}.to_mash
+    self.relationship_descriptions = {}.to_mash
+
+    def self.method_added method_name
+      if documented = inline_description
+        attribute_descriptions[method_name.to_sym] = documented
+      end
+    end
+
+    def self.schema_attributes
+      schema[:attributes]
+    end
+
+    def self.schema_associations
+      schema[:associations]
+    end
+
+    def self.configure options, resource=nil
+      resource ||= Smooth.current_resource
+      klass = define_or_open(options, resource)
+
+      Array(options.blocks).each do |blk|
+        klass.class_eval(&blk)
+      end
+
+      klass
+    end
+
+    def self.define_or_open(options, resource)
+      resource_name = resource.name
+      base          = Smooth.serializer
+
+      name = options.name
+      name = nil if name == "Default"
+
+      klass = "#{ resource_name }#{ name }".singularize + "Serializer"
+
+      if serializer_klass = Object.const_get(klass) rescue nil
+        return serializer_klass
+      end
+
+      Object.const_set(klass, Class.new(base))
+    end
+
+    def self.documentation_for_attribute attribute
+      attribute_descriptions[attribute.to_sym]
+    end
+
+    def self.documentation_for_association association
+      relationship_descriptions[association.to_sym]
+    end
+
+    def self.documentation
+      attribute_descriptions.merge(relationship_descriptions).to_mash
+    end
+
+    def self.attribute attr, options={}
+      documented = inline_description
+
+      if documented
+        attribute_descriptions[attr.to_sym] = documented
+      end
+
+      super
+    end
+
+    def self.has_one attr, options={}
+      documented = inline_description
+
+      if documented
+        relationship_descriptions[attr.to_sym] = documented
+      end
+
+      super
+    end
+
+    def self.has_many attr, options={}
+      documented = inline_description
+
+      if documented
+        relationship_descriptions[attr.to_sym] = documented
+      end
+
+      super
+    end
+  end
+end