smooth 2.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4909a00991f205fc93b1ed479717c74635f3bef5
+  data.tar.gz: 3dbf7cda0d581469b22a297f6a0e8b9022e76583
+SHA512:
+  metadata.gz: b8026b76b623987b8428fce674926a2b1a7e171d87eb86ec4c0321b481d6223205d0f9d9be5c393453534e61937446211ac1b59ddf3257c86985ff5b336d891c
+  data.tar.gz: ade1e5f9874ea6e897ff152964d29ea4b1bea9837d8b313ad5adc66bd155ae90607a649c7a9b6debf6c892a12740a934bdbbe2d18e7868d4b293db344249f911

data/.gitignore

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

data/Gemfile

@@ -0,0 +1,10 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in smooth.gemspec
+gemspec
+
+group :test, :development do
+  gem 'pry'
+  gem 'pry-nav'
+  gem 'mutations', github: "datapimp/mutations", branch: "inline-documentation"
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Jonathan Soeder
+
+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,29 @@
+# Smooth
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'smooth'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install smooth
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,24 @@
+require "bundler/gem_tasks"
+
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+APP_RAKEFILE = File.expand_path("../spec/dummy/Rakefile", __FILE__)
+load 'rails/tasks/engine.rake'
+
+Bundler::GemHelper.install_tasks
+
+Dir[File.join(File.dirname(__FILE__), 'tasks/**/*.rake')].each {|f| load f }
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+
+desc "Run all specs in spec directory (excluding plugin specs)"
+
+RSpec::Core::RakeTask.new(:spec => 'app:db:test:prepare')
+
+task :default => :spec

data/config/routes.rb

@@ -0,0 +1,2 @@
+Rails.application.routes.draw do
+end

data/lib/smooth.rb

@@ -0,0 +1,64 @@
+$:.unshift File.dirname(__FILE__)
+
+begin
+  require 'hashie'
+  require 'active_support/core_ext'
+  require 'active_support/notifications'
+  require 'active_model_serializers'
+  require 'mutations'
+  require 'pry'
+rescue LoadError
+  require 'rubygems'
+  require 'hashie'
+  require 'active_support/core_ext'
+  require 'pry'
+end
+
+
+require "smooth/ext/core"
+require "smooth/documentation"
+require "smooth/event"
+
+require "smooth/api"
+require "smooth/cache"
+require "smooth/command"
+require "smooth/example"
+require "smooth/query"
+require "smooth/resource"
+require "smooth/serializer"
+
+require "smooth/configuration"
+require "smooth/version"
+
+module Smooth
+  extend Smooth::Api::Tracking
+  extend Smooth::Resource::Tracking
+  extend Smooth::Event::Adapter
+
+  def self.command
+    config.command_class
+  end
+
+  def self.query
+    config.query_class
+  end
+
+  def self.serializer
+    config.serializer_class
+  end
+
+  def self.config
+    Smooth::Configuration.instance
+  end
+
+  class Engine < ::Rails::Engine
+    initializer 'smooth.load_resources', :before => :build_middleware_stack do |app|
+      app_root = app.config.root.join("app")
+
+      %w{smooth apis resources}.each do |check_folder|
+        app_root.join(check_folder).children.each {|f| require(f) } if app_root.join(check_folder).exist?
+      end
+    end
+
+  end if defined?(::Rails)
+end

data/lib/smooth/api.rb

@@ -0,0 +1,72 @@
+require 'smooth/dsl'
+
+module Smooth
+  class Api
+    include Smooth::Documentation
+
+    def self.default
+      @default ||= Smooth::Api.new
+    end
+
+    attr_accessor :name,
+                  :_version_config,
+                  :_resources,
+                  :_policies
+
+    def initialize(name, options={})
+      @name       = name
+      @options    = options
+
+      @_resources   = {}
+      @_policies    = {}
+    end
+
+    def version config=nil
+      @_version_config = config if config
+      @_version_config
+    end
+
+    def policy policy_name, options={}, &block
+      if obj = _policies[policy_name.to_sym]
+        obj.apply_options(options) unless options.empty?
+        obj.instance_eval(&block) if block_given?
+        obj
+
+      elsif options.empty? && !block_given?
+        nil
+
+      elsif block_given?
+        obj = Smooth::Api::Policy.new(policy_name, options, &block)
+        _resources[policy_name.to_sym] = obj
+      end
+    end
+
+    def has_resource? resource_name
+      resources.has_key?(resource_name.to_sym)
+    end
+
+    def resource resource_name, options={}, &block
+      api_name = self.name
+
+      if existing = _resources[resource_name.to_sym]
+        existing.apply_options(options) unless options.empty?
+        existing.instance_eval(&block) if block_given?
+        existing
+
+      elsif options.empty? && !block_given?
+        existing = nil
+
+      elsif block_given?
+        created = Smooth::Resource.new(resource_name, options, &block).tap do |obj|
+          obj.api_name = api_name
+        end
+
+        _resources[resource_name.to_sym] = created
+      end
+    end
+
+  end
+end
+
+require 'smooth/api/tracking'
+require 'smooth/api/policy'

data/lib/smooth/api/policy.rb

@@ -0,0 +1,18 @@
+module Smooth
+  class Api
+    class Policy
+      include Smooth::Documentation
+
+      attr_accessor :name
+
+      def initialize name, options={}
+        @name = name
+        @options = options
+      end
+
+      def apply_options *opts
+        @options.send(:merge!, *opts)
+      end
+    end
+  end
+end

data/lib/smooth/api/tracking.rb

@@ -0,0 +1,31 @@
+module Smooth
+  class Api
+    module Tracking
+      def apis
+        @@apis ||= {}
+      end
+
+      def fetch_api name, &block
+        existing = apis[name.to_sym]
+
+        if existing.nil? && block_given?
+          existing = apis[name.to_sym] = block.call(name.to_sym)
+        end
+
+        existing
+      end
+
+      def current_api
+        apis[current_api_name] ||= Smooth::Api.default()
+      end
+
+      def current_api_name= value
+        @@current_api_name = value
+      end
+
+      def current_api_name
+        (@@current_api_name || :default).to_sym
+      end
+    end
+  end
+end

data/lib/smooth/cache.rb

@@ -0,0 +1,19 @@
+require 'singleton'
+
+module Smooth
+  def self.cache
+    Smooth::Cache.instance
+  end
+
+  class Cache
+    include Singleton
+
+    def method_missing meth, *args, &block
+      if defined? ::Rails
+        return ::Rails.cache.send(meth, *args, &block)
+      end
+
+      super
+    end
+  end
+end

data/lib/smooth/command.rb

@@ -0,0 +1,55 @@
+require 'smooth/ext/mutations'
+require 'smooth/command/instrumented'
+
+class Smooth::Command < Mutations::Command
+  include Instrumented
+
+  class_attribute :resource_name,
+                  :command_action,
+                  :event_namespace
+
+  def self.scope setting
+    @@scope = setting
+  end
+
+  def self.params *args, &block
+    send(:required, *args, &block)
+  end
+
+  def self.event_namespace
+    @event_namespace || "#{ command_action }.#{ resource_name.singularize.underscore }".downcase
+  end
+
+  def event_namespace; self.class.event_namespace; end
+
+  # DSL Hooks
+  #
+  #
+  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.to_s.singularize
+    base          = Smooth.command
+
+    name = options.name.to_s.camelize
+    klass = "#{ name }#{ resource_name }"
+
+    if command_klass = Object.const_get(klass) rescue nil
+      return command_klass
+    end
+
+    Object.const_set(klass, Class.new(base)).tap do |k|
+      k.resource_name = resource.name.to_s
+      k.command_action  = options.name.to_s
+    end
+  end
+end

data/lib/smooth/command/instrumented.rb

@@ -0,0 +1,51 @@
+module Smooth
+  class Command < Mutations::Command
+    module Instrumented
+      def self.included(base)
+        base.extend(ClassMethods)
+        base.enable_event_tracking! # if Smooth.config.enable_event_tracking_by_default?
+      end
+
+      module Overrides
+        def run
+          run_with_instrumentation
+        end
+      end
+
+      module Restored
+        def run
+          run_with_outcome
+        end
+      end
+
+      module ClassMethods
+        def enable_event_tracking!
+          send(:include, Smooth::Event::Adapter)
+          send(:include, Overrides)
+        end
+
+        def disable_event_tracking!
+          send(:include, Restored)
+        end
+      end
+
+      def run_with_instrumentation
+        outcome = run_with_outcome
+
+        if outcome.success?
+          result = outcome.result
+          track_event("#{ event_namespace }", result: result, inputs: inputs)
+          result
+        else
+          track_event("errors/#{ event_namespace }", errors: outcome.errors, inputs: inputs)
+          outcome
+        end
+      end
+
+      def run_with_outcome
+        return validation_outcome if has_errors?
+        validation_outcome(execute)
+      end
+    end
+  end
+end