smooth-io 0.0.5

data/lib/smooth/collection/cacheable.rb

@@ -0,0 +1,12 @@
+module Smooth
+  class Collection
+    module Cacheable
+      def create_cache_adapter(options)
+        case options[:backend]
+        when "redis"
+          Smooth::Adapters::RedisCache.new(options)
+        end
+      end
+    end
+  end
+end

data/lib/smooth/collection/query.rb

@@ -0,0 +1,14 @@
+module Smooth
+  class Collection
+    class Query < Hash
+
+      def initialize options={}
+        self.merge!(options)
+      end
+
+      def cache_key
+        self.keys.sort.inject([]) {|memo, key| memo << "#{ key }:#{ self.send(:[], key) }" }.join("/")
+      end
+    end
+  end
+end

data/lib/smooth/endpoint.rb

@@ -0,0 +1,23 @@
+require "sinatra/base"
+require "sinatra/json"
+
+module Smooth
+  class Endpoint < Sinatra::Base
+    helpers Sinatra::JSON
+
+    def self.interface_for(model_class, options={})
+      collection    = model_class.collection
+      resource_name = options.fetch(:resource_name, collection.namespace)
+      prefix        = options.fetch(:prefix, "/smooth/api/v1")
+
+      get "#{ prefix }/#{ resource_name }" do
+        json collection.query(params)
+      end
+
+      get "#{ prefix }/#{ resource_name }/:id" do
+        json collection.show(params[:id])
+      end
+
+    end
+  end
+end

data/lib/smooth/meta_data.rb

@@ -0,0 +1,33 @@
+require "smooth/meta_data/inspector"
+
+module Smooth
+  module MetaData
+    def self.resource_settings
+      @resource_settings ||= {}
+    end
+
+    def self.register_resource(resource, options={})
+      resource = resource.to_s.camelize.constantize if resource.is_a?(String) or resource.is_a?(Symbol)
+      resource_settings[resource.to_s] = Inspector.new(resource)
+
+      resource.to_s
+    end
+
+    def self.resources
+      resource_settings.inject({}) do |memo,pair|
+        resource_name, inspector = pair
+        memo[resource_name] = inspector.as_json
+        memo
+      end
+    end
+
+    def self.available_resources
+      resource_settings.keys
+    end
+
+    def self.[] resource_name
+      resource_settings[resource_name]
+    end
+
+  end
+end

data/lib/smooth/meta_data/application.rb

@@ -0,0 +1,29 @@
+require 'sinatra'
+
+module Smooth
+  module MetaData
+    class Application < Sinatra::Base
+      def resources
+        @resources ||= Smooth::MetaData.resources
+      end
+
+      get "/" do
+        content_type :json
+        resources.to_json
+      end
+
+      get "/:resource" do
+
+        content_type :json
+        camelized = params[:resource].camelize
+        info = resources[camelized]
+
+        if !info
+          halt 404 and return
+        end
+
+        info.to_json
+      end
+    end
+  end
+end

data/lib/smooth/meta_data/inspector.rb

@@ -0,0 +1,67 @@
+module Smooth
+  module MetaData
+    class Inspector
+      attr_accessor :resource
+
+      def initialize(resource)
+        @resource = resource
+        @resource = resource.to_s.camelize.constantize if resource.is_a?(String) or resource.is_a?(Symbol)
+      end
+
+      def presenters
+        methods = [:default]
+        methods += resource.presenter_class.public_methods - Object.methods
+
+        methods.uniq
+      end
+
+      def queryable_parameters
+        resource.queryable_keys
+      end
+
+      def queryable_settings
+      end
+
+      def resource_is_presentable?
+        resource && resource.ancestors.include?(Smooth::Presentable)
+      end
+
+      def resource_is_queryable?
+        resource && resource.ancestors.include?(Smooth::Queryable)
+      end
+
+      def presentable_settings
+        return {} unless resource_is_presentable?
+
+        {
+          presentable: {
+            formats: presenters
+          }
+        }
+      end
+
+      def queryable_settings
+        return {} unless resource_is_queryable?
+
+        {
+          queryable:{
+            parameters: queryable_parameters,
+            settings: resource.smooth_queryable_settings.to_hash
+          }
+        }
+      end
+
+      def to_hash
+        hash = {}
+        hash.merge!(presentable_settings)
+        hash.merge!(queryable_settings)
+
+        hash
+      end
+
+      def as_json
+        to_hash
+      end
+    end
+  end
+end

data/lib/smooth/model.rb

@@ -0,0 +1,93 @@
+require 'json'
+
+module Smooth
+  class Model
+    include Virtus
+
+    attr_accessor :model_attributes, :collection, :model_options
+
+    InvalidRecord = Class.new(Exception)
+    InvalidCollection = Class.new(Exception)
+
+    def initialize(attributes={},options={})
+      options ||= {}
+      attributes ||= {}
+
+      @model_options  = options.dup
+      @collection     = options[:collection] if options[:collection]
+
+      raise InvalidRecord unless attributes.is_a?(Hash)
+
+      unless respond_to?(:id)
+        extend(Virtus)
+        self.class.attribute :id, String unless respond_to?(:id)
+      end
+
+      super(attributes)
+    end
+
+    # This should delegate to the collection sync method
+    # which is capable of getting a single record
+    def sync method=:read, *args
+      raise InvalidCollection unless collection && collection.respond_to?(:sync)
+
+      case
+
+      when is_new?
+        self.id = collection.sync(:create, self).id
+      when !is_new? && method == :update
+        collection.sync(:update, self)
+      else
+        collection.sync(:read)
+      end
+
+      fetch
+    end
+
+    def save
+      is_new? ? sync(:create) : sync(:update)
+    end
+
+    def update_attributes attributes={}
+      self.send(:set_attributes, attributes)
+      save
+    end
+
+    # the collection should implement this single object find
+    def fetch
+      return self unless self.id
+
+      model = collection.models.detect do |item|
+        item[id_field].to_s == self.id.to_s
+      end
+
+      if model && model.attributes.is_a?(Hash)
+        self.send(:set_attributes, model.attributes)
+      end
+
+      self
+    end
+
+    def is_new?
+      id.nil?
+    end
+
+    def id
+      attributes.fetch(:id, nil)
+    end
+
+    def as_json options={}
+      to_hash rescue @attributes
+    end
+
+    def to_json options={}
+      JSON.generate(as_json(options))
+    end
+
+    protected
+
+      def id_field
+        model_options.fetch(:id_field, :id)
+      end
+  end
+end

data/lib/smooth/presentable.rb

@@ -0,0 +1,76 @@
+module Smooth
+
+  class DefaultPresenter
+    def default
+      [:id]
+    end
+  end
+
+  module Presentable
+    extend ActiveSupport::Concern
+
+    included do
+      Smooth::MetaData.register_resource(self)
+    end
+
+    def present_as(format=:default)
+      record  = self
+      keys    = self.class.presenter_class && self.class.presenter_class.respond_to?(format) && self.class.presenter_class.send(format)
+      keys    ||= self.class.default_presenter_attributes
+
+      Array(keys).inject({}) do |memo,item|
+        AttributeDelegator.pluck(record, item, memo)
+      end
+    end
+
+    class AttributeDelegator
+      def self.pluck(record, attribute, memo)
+        if attribute.is_a?(Symbol) || attribute.is_a?(String)
+          memo[attribute] = record.send(attribute)
+          return memo
+        end
+
+        if attribute.is_a?(Hash)
+          key         = attribute[:attribute] || attribute[:key]
+          meth        = attribute[:method] || key
+          presenter   = attribute[:presenter] || :default
+
+          value       = record.send(meth)
+
+          memo[key] = value.send(:present_as, presenter)
+        end
+
+        return memo
+      end
+    end
+
+    module ClassMethods
+      def presenter_class
+        "#{ to_s }Presenter".constantize rescue nil
+      end
+
+      def default_presenter_attributes
+        if respond_to?(:column_names)
+          column_names.map(&:to_sym)
+        end
+      end
+
+      def presenter_format_for_role(recipient=:default, format=:default)
+        if presenter_class.respond_to?("#{ recipient }_#{ format }")
+          "#{ recipient }_#{ format }"
+        elsif presenter_class.respond_to?("#{ format }")
+          format
+        else
+          :default
+        end
+      end
+
+      def present params={}
+        scope = scoped
+        scope = query(params) if ancestors.include?(Smooth::Queryable)
+
+        Smooth::Presentable::Chain.new(scope)
+      end
+    end
+  end
+end

data/lib/smooth/presentable/api_endpoint.rb

@@ -0,0 +1,49 @@
+module Smooth
+  module Presentable
+    class ApiEndpoint < Sinatra::Base
+
+      get "/:resource" do
+        halt 404 unless valid_resource?
+        index.to_json
+      end
+
+      get "/:resource/:presenter" do
+        halt 404 unless valid_resource?
+        index.to_json
+      end
+
+
+      def resource_model
+        params[:resource] && params[:resource].singularize.camelize.constantize rescue nil
+      end
+
+      def valid_resource?
+        resource_model && resource_model.ancestors.include?(Smooth::Presentable)
+      end
+
+      def presenter_format
+        params[:presenter] || params[:presenter_format] || :default
+      end
+
+      def base_scope
+        resource_model
+      end
+
+      def current_user_role
+        :default
+      end
+
+      def index
+        base_scope.present(params)
+          .as(presenter_format)
+          .to(current_user_role).results
+      end
+
+      def show
+        record = base_scope.find(params[:id])
+        record.present_as(presenter_format)
+      end
+
+    end
+  end
+end

data/lib/smooth/presentable/chain.rb

@@ -0,0 +1,46 @@
+module Smooth
+  module Presentable
+    # The Chain allows for constructing an API call with the following:
+    #
+    # Resource.present(query)
+    #   .as(format)
+    #   .to(user)
+    #
+    class Chain
+      attr_accessor :scope, :format, :recipient, :presenter_method
+
+      def initialize(scope)
+        @scope      = scope
+        @format     = :default
+        @recipient  = :default
+      end
+
+      def as(format=:default)
+        @format = format
+        self
+      end
+
+      def to(recipient=:default)
+        @recipient = recipient
+        self
+      end
+
+      def results
+        @presenter_method ||= scope.klass.presenter_format_for_role(recipient, format)
+
+        @results ||= scope.map do |record|
+          record.present_as(presenter_method)
+        end
+      end
+
+      def to_a
+        results
+      end
+
+      def method_missing meth, *args, &block
+        results.send(meth, *args, &block)
+      end
+
+    end
+  end
+end