restafarian 0.0.1.pre

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e073edea878d46f79bdb347c2443e56d53bd67ba
+  data.tar.gz: 4f82325b2663a332dfdb9061cd3bf09551d70e6e
+SHA512:
+  metadata.gz: 3c6b392986527f19a4491db37dbf78765f5166668f18816f963d58eb6b9569a5b686348a5de0017fe2864c86a422614aa67bb7cae4a986947c9be2a379468db9
+  data.tar.gz: 02da1529fd207b4d36627fc72da1edf30e56aa4aaccd33771db712bf43d41187b3931ac1931dad95b3ee748dd1f86b930330c1488be21fb764c9cc7a30659007

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2013 YOURNAME
+
+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/Rakefile

@@ -0,0 +1,21 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Restafarian'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+
+
+Bundler::GemHelper.install_tasks
+

data/lib/restafarian.rb

@@ -0,0 +1,32 @@
+require 'uncle'
+require 'restafarian/engine'
+require 'restafarian/request'
+require 'restafarian/type_hinter'
+require 'restafarian/responder'
+require 'restafarian/javascript_renderer'
+
+module Restafarian
+
+end
+
+ActionDispatch::Routing::Mapper.class_eval do
+  def restafarian_routes
+    root 'restafarian/root#index'
+  end
+end
+
+Mime::Type.register \
+  'application/vnd.restafarian+json', :restafarian_json
+
+Mime::Type.register \
+  'application/vnd.restafarian+js', :restafarian_js
+
+ActionController::Renderers.add(:restafarian_json) do |object, options|
+  self.content_type ||= Mime::RESTAFARIAN_JSON
+  object.kind_of?(String) ? object : object.to_json(options)
+end
+
+ActionController::Renderers.add(:restafarian_js) do |object, options|
+  self.content_type ||= Mime::RESTAFARIAN_JS
+  Restafarian::JavascriptRenderer.new(object).render
+end

data/lib/restafarian/controllers/restafarian/controller.rb

@@ -0,0 +1,7 @@
+module Restafarian
+  class Controller < ActionController::Base
+    respond_to :restafarian_js, :restafarian_json
+    
+    self.responder = Restafarian::Responder
+  end
+end

data/lib/restafarian/controllers/restafarian/root_controller.rb

@@ -0,0 +1,9 @@
+module Restafarian
+  class RootController < ::ApplicationController
+    def index
+      # raise request.path.inspect
+      render json: { child_resources: child_resources },
+             content_type: 'application/vnd.restafarian+json'
+    end
+  end
+end

data/lib/restafarian/engine.rb

@@ -0,0 +1,5 @@
+module Restafarian
+  class Engine < Rails::Engine
+    paths["app/controllers"] << "lib/restafarian/controllers"
+  end
+end

data/lib/restafarian/javascript_renderer.rb

@@ -0,0 +1,86 @@
+module Restafarian
+  class JavascriptRenderer < Struct.new(:object)
+    TEMPLATE_PATH = Engine.root + 'lib/restafarian/templates'
+    JS_TEMPLATE   = File.read(TEMPLATE_PATH + 'representation.js.erb')
+    VALIDATORS    = YAML.load(File.read(TEMPLATE_PATH + 'validators.yml'))
+    ERROR_MAPPING = {
+      presence: [:blank], absence: [:present], length: %i<too_short too_long>,
+      acceptance: [:accepted], inclusion: [:inclusion],
+      confirmation: [:confirmation], numericality: %i<not_a_number not_an_integer>,
+      exclusion: [:exclusion], format:[:invalid]
+    }
+
+    def render
+      ERB.new(JS_TEMPLATE, $SAFE, '>').result(binding).each_line.map(&:strip).join
+    end
+
+    private
+
+    def typed_properties
+      ActiveSupport::JSON.encode(object_typed_properties)
+    end
+
+    def validators
+      VALIDATORS.slice(*pertinent_validators).
+        map { |k,v| "#{k}:#{(v % errors_for(k))}" }.join ","
+    end
+
+    def errors_for(key)
+      ERROR_MAPPING[key].map { |k| I18n.t('errors.messages')[k] }
+    end
+
+    def pertinent_validators
+      names = object_as_json.keys.inject([]) do |memo, key|
+        validators = object.class.validators_on(key).reject do |validator|
+          validator.options[:on] == (object.new_record? ? :create : :update)
+        end
+
+        memo.push *validators.map(&:kind)
+      end
+
+      names.uniq
+    end
+
+    def type_hinter
+      @type_hinter ||= TypeHinter.new(object.class)
+    end
+
+    def object_validators_on(property)
+      object.class.validators_on(property).reduce({}) do |memo, validator|
+        options = process_options(validator.options)
+        memo.merge validator.kind => options
+      end
+    end
+
+    def object_as_json
+      object.as_json
+    end
+
+    def object_name
+      object.class.name.humanize
+    end
+
+    def object_typed_properties
+      object_as_json.reduce({}) do |memo, (property, value)|
+        memo.merge property => {
+          label:      property.humanize,
+          type:       type_hinter.hint(property),
+          validators: object_validators_on(property)
+        }
+      end
+    end
+
+    def process_options(options)
+      opts = options.map do |k,v|
+        case v
+        when Regexp
+          v = v.source
+        end
+
+        [k, v]
+      end
+
+      Hash[opts]
+    end
+  end
+end

data/lib/restafarian/request.rb

@@ -0,0 +1,19 @@
+module Restafarian
+  class Request < Struct.new(:request) # :nodoc:
+    def acceptable_http_methods
+      node = routeset.routes.match(request.path).detect do |node|
+        node.value.any? do |r|
+          r.path.to_regexp === request.path && r.matches?(request)
+        end
+      end
+
+      node.value.map { |route| route.verb.source.gsub(/[^\w]/, '') }
+    end
+
+    private
+
+    def routeset
+      Rails.application.routes
+    end
+  end
+end

data/lib/restafarian/responder.rb

@@ -0,0 +1,15 @@
+module Restafarian
+  class Responder < ActionController::Responder
+    def to_restafarian_js
+      request = Restafarian::Request.new(controller.request)
+      controller.response.headers['Allow'] = request.acceptable_http_methods.join(', ')
+
+      controller.render restafarian_js: resource
+    end
+
+    def to_restafarian_json
+      controller.render restafarian_json: resource
+    end
+
+  end
+end

data/lib/restafarian/templates/representation.js.erb

@@ -0,0 +1,41 @@
+(function() {
+  "use strict";
+  var validators = { <%= validators %>  };
+  var fmt = function(error) {
+    return error[0].replace(/%{(\w+)}/, function(match, capture) {
+      return error[1][capture];
+    });
+  };
+  var resource = {
+    label: "<%= object_name %>",
+    properties: <%= typed_properties %>,
+    validate: function(representation) {
+      var errors = {};
+
+      for(var property in this.properties) {
+        errors[property] = [];
+
+        for(var validator in this.properties[property].validators) {
+          if(!validators[validator]) continue;
+
+          var options = this.properties[property].validators[validator];
+          var error = validators[validator].call(representation, property, options);
+
+          var defaults = {
+            attribute: property,
+            value: representation[property],
+            model: this.label
+          };
+
+          if(error) {
+            for(var key in defaults) error[1][key] = defaults[key];
+            errors[property].push(fmt(error));
+          }
+        }
+      }
+
+      return errors;
+    }
+  };
+  return resource;
+})();

data/lib/restafarian/templates/validators.yml

@@ -0,0 +1,67 @@
+:presence: |
+  function(property, options) {
+    if(!this[property]) {
+      return ["%s", {}];
+    }
+  }
+:absence: |
+  function(property, options) {
+    if(this[property]) {
+      return ["%s", {}];
+    }
+  }
+:length: |
+  function(property, options) {
+    property = this[property];
+
+    if(options.minimum && property.length < options.minimum) {
+      return ["%s", { count: options.minimum }];
+    }
+
+    if(options.maximum && property.length > options.maximum) {
+      return ["%s", { count: options.maximum }];
+    }
+  }
+:acceptance: |
+  function(property, options) {
+    if(!this[property]) {
+      return ["%s", {}];
+    }
+  }
+:inclusion: |
+  function(property, options) {
+    if(options['in'].indexOf(this[property]) < 0) {
+      return ["%s", {}];
+    }
+  }
+:confirmation: |
+  function(property, options) {
+    if(this[property] != this[property + '_confirmation']) {
+      return ["%s", {}];
+    }
+  }
+:numericality: |
+  function(property, options) {
+    var number = parseInt(this[property], 10);
+    if(!number) {
+      return ["%s", {}];
+    }
+
+    if(options.only_integer && (String(number) != this[property])) {
+      return ["%s", {}];
+    }
+  }
+:exclusion: |
+  function(property, options) {
+    if(options['in'].indexOf(this[property]) > -1) {
+      return ["%s", {}];
+    }
+  }
+:format: |
+  function(property, options) {
+    var re = new RegExp(options.with);
+
+    if(!this[property].match(re)) {
+      return ["%s", {}];
+    }
+  }

data/lib/restafarian/type_hinter.rb

@@ -0,0 +1,56 @@
+module Restafarian
+  class TypeHinter < Struct.new(:klass)
+    def hint(property)
+      infer_from_column(property) ||
+      infer_from_validators(property) ||
+      infer_from_property_name(property)
+    end
+
+    private
+
+    def infer_from_property_name property
+      case property.to_s.gsub('_', ' ')
+      when /\bemail\b/ then :email
+      when /\bphoto\b/, /\bimage\b/, /\bavatar\b/, /\bpicture\b/ then :image
+      when /\bfile\b/ then :file
+      when /\bpassword\b/ then :password
+      when /\btelephone\b/, /\bphone\b/ then :tel
+      when /\burl\b/ then :url
+      when /\bnumber\b/ then :number
+      else :text
+      end
+    end
+
+    def infer_from_column(property)
+      case mapping[property]
+      when :decimal, :float, :integer then :number
+      when :datetime then :datetime
+      end
+    end
+
+    def infer_from_validators(property)
+      validators = klass.validators_on(property)
+      inclusion_validator = validators.detect { |v| v.kind == :inclusion }
+
+      case
+      when validators.any? { |v| v.kind == :acceptance }
+        :checkbox
+      when inclusion_validator.present?
+        infer_from_inclusion_validator \
+          inclusion_validator
+      end
+    end
+
+    def infer_from_inclusion_validator(validator)
+      type = validator.options[:in].map do |i|
+        [i.humanize, i]
+      end
+
+      Hash[type]
+    end
+
+    def mapping
+      Hash[klass.column_types.map { |k,v| [k, v.type] }].with_indifferent_access
+    end
+  end
+end

data/lib/restafarian/version.rb

@@ -0,0 +1,3 @@
+module Restafarian
+  VERSION = "0.0.1.pre"
+end

data/lib/tasks/restafarian_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :restafarian do
+#   # Task goes here
+# end

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification
+name: restafarian
+version: !ruby/object:Gem::Version
+  version: 0.0.1.pre
+platform: ruby
+authors:
+- Stevie Graham
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-05-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.14'
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+description: Expose fully RESTful HTTP APIs including code-on-demand so client can
+  intelligent present most appropriate UI element for each property & perform arbitrary,
+  non-authorative, client-side validations before submitting data to the API server.
+email:
+- sjtgraham@mac.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- Rakefile
+- lib/restafarian.rb
+- lib/restafarian/controllers/restafarian/controller.rb
+- lib/restafarian/controllers/restafarian/root_controller.rb
+- lib/restafarian/engine.rb
+- lib/restafarian/javascript_renderer.rb
+- lib/restafarian/request.rb
+- lib/restafarian/responder.rb
+- lib/restafarian/templates/representation.js.erb
+- lib/restafarian/templates/validators.yml
+- lib/restafarian/type_hinter.rb
+- lib/restafarian/version.rb
+- lib/tasks/restafarian_tasks.rake
+homepage: https://github.com/stevegraham/restafarian
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.0.rc.1
+signing_key: 
+specification_version: 4
+summary: A tool for implementing real REST HTTP APIs.
+test_files: []