immanence 0.0.2 → 0.1.1

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    MDcyOTJhNmQ0NTc5MDU4MjhkYTVmMGJiNTRmZjU5MWU4NTRmNzY3ZQ==
+    MTZkMWFhOGNhODAxOGMyNzYyNTcwNDBhMmEzZWVjNTc3ZTk4ODJlYQ==
   data.tar.gz: !binary |-
-    MDJkZmNlNGQ1ZDQ5MDJiMjRhMTIxMjAyNTdmMGM0NWU0ZmYyN2RlOQ==
+    YTA5MWZmZDk3NjY2NTc4ZmVhMmNkMjk0Yzg1ZGIwMzVhMDVkMDMzNg==
 !binary "U0hBNTEy":
   metadata.gz: !binary |-
-    N2IzMTc4Mjg4Y2Y4MDM3MTBjYzYyOTA0MGI3NDZkN2RkOWE4NWFmYjcxNzNk
-    ZDFmMzQyNmUzYzQ0ZDQ2ZGIxYTE1MjliZDZiZjYyNGUwYjhiNDA3Mzg1Y2E1
-    MmIwODhhMzI2MTliZTgwYjE0NGU0MmNiNjNhZDNkZjQ0YzMxYjY=
+    MTUzNjdjMTQ1NmI5NmNiYjdlYTdkNmVhNWJlMzVkNjMzYjEwMGY0MjdlNDk5
+    NzQwYzU5ODZkNmIxYTM2N2I5MWRhMjM3OGYwODExYzJhZmQ4ZWZmZWZmZjA4
+    Yzg3NjI4NDc5M2YwYjA0N2ZiYjZkZDQ3NjBiNmNmYjZiOGFhNDk=
   data.tar.gz: !binary |-
-    NjE0MGRkN2I2NDhjZGRjNmU4YzM1ODVjNDYzMWIwNDAzNmUxN2M1NjliMjE2
-    MmNjYzNkMWQ5ZWE0ZTg0NzRkOTQyYmJhYTRhYmZkY2NkZjk3ZmQ3M2YwOTIx
-    ZDQwZDIzYmY2MTI2OWY1NDJlOGUyNTJjNTQwZDQ4NDc2NTJkNzU=
+    Zjk3ZGJmZmI4YjA3OTljMjBkNmU2ZDBmNjJlNzgwNjE4ZGJmZGI0NDEwNzQy
+    YjFiMzE1MDgyNWRmNzE0Mjc5ZjYyMzcxYTg2YWQ3OWY3MTg2OWY2ZWM0NjEw
+    OGI4MjUzYjU1MTlhMzVlZDdlZmJjNjYwNGQ0NmEyZDMyOTc0NDE=

data/README.md

@@ -9,18 +9,20 @@
 >
 > —Arakawa and Madeline Gins
 
-**Immanence** is a DSL for handling web requests in Ruby, built on top of Rack. To execute routes it calculates the [Levenshtein distance](http://en.wikipedia.org/wiki/Levenshtein_distance) between incoming requests and routes defined in the DSL then executes the most likely candidate. *Something will always be executed.* Objects are rendered by calling `>>` on `self` with the object to be rendered as the argument. Objects are serialized into JSON via Oj. Incoming JSON is automatically parsed and available in the `@request` object.
+**Immanence** is a DSL for handling web requests in Ruby, built on top of Rack. To execute routes it calculates the [Levenshtein distance](http://en.wikipedia.org/wiki/Levenshtein_distance) between incoming requests and routes defined through the DSL then executes the most likely candidate. *Something will always be executed.* Objects are rendered by calling `→` (alias `render`) with the object to be rendered as the argument. Object responses are encoded as JSON. Incoming JSON is automatically parsed and available in as the `input` object.
 
-This is less a useful piece of software and more of a stylistic exercise.
+What does it mean to discard transparent precision in favor of immanent promiscuity?
 
 ```ruby
-class Application < Immanence::Control
+# encoding: UTF-8
+
+class Application < Immanent::Control
   route :get, "/fields/:id" do
-    self >> Field.find(@params[:id])
+    → Field.find(params[:id])
   end
 
   route :post, "/fields" do
-    self >> Field.create(@request.input)
+    → Field.create(input)
   end
 end
 ```

data/Rakefile

@@ -4,3 +4,12 @@ desc "Open an irb session preloaded with this library"
 task :console do
   sh "irb -rubygems -I lib -r immanence.rb"
 end
+
+desc "Run specs"
+task :spec do
+  require "rspec/core/rake_task"
+
+  RSpec::Core::RakeTask.new(:spec) do |spec|
+    spec.rspec_opts = %w{--colour --format progress}
+  end
+end

data/lib/immanence.rb

@@ -8,77 +8,98 @@ require "core_ext/hash"
 require "core_ext/object"
 
 module Immanence
-  class Request < Struct.new(:verb, :path, :input); end
+  class Request
+    attr_reader :input
+
+    def initialize(request, input)
+      @__request__  = request
+      @input = input
+    end
+
+    def method_missing(method, *args, &block)
+      @__request__.send(method, *args, &block)
+    end
+  end # Request
 
   class Control
     I = λ { |i| Oj.load(i) }
     O = λ { |o| Oj.dump(o, mode: :compat) }
 
-    LEVENSHTEIN = λ { |a, b|
-      mx = [(0..a.size).to_a]
-
-      (1..b.size).each do |j|
-        mx << [j] + [0] * (a.size)
-      end
+    LEVENSHTEIN = λ do |a, b|
+      [(0..a.size).to_a].tap { |mx|
+        (1..b.size).each do |j|
+          mx << [j] + [0] * (a.size)
+        end
 
-      (1..b.size).each do |i|
-        (1..a.size).each do |j|
-          if a[j-1] == b[i-1]
-            mx[i][j] = mx[i-1][j-1]
-          else
-            mx[i][j] = [
-              mx[i-1][j],
-              mx[i][j-1],
-              mx[i-1][j-1]
-            ].min + 1
+        (1..b.size).each do |i|
+          (1..a.size).each do |j|
+            if a[j-1] == b[i-1]
+              mx[i][j] = mx[i-1][j-1]
+            else
+              mx[i][j] = [
+                mx[i-1][j],
+                mx[i][j-1],
+                mx[i-1][j-1]
+              ].min + 1
+            end
           end
         end
-      end
-
-      mx[-1][-1]
-    }
+      }[-1][-1]
+    end
 
     class << self
-      def >>(body=:ok, options={}, headers={})
-        body = O[body]
+      alias_method :delegate_to, :send
 
-        options.reverse_merge!({ status: 200 })
+      # Convenience methods
+      def request() @request end
+      def input() request.input end
+      def params() ascertain(receiver, request.path).reverse_merge!(request.params) end
+
+      # Naive implementation
+      def before(&blk) yield end
 
-        headers.reverse_merge!({
-          "Content-Type"      => "text/json",
-          "Content-Length"    => ("#{body.size}" rescue "0")
-        })
+      # Interface with Rack
+      def call(env)
+        @request = Request.new(Rack::Request.new(env), I[env["rack.input"]])
 
-        [options[:status], headers, [body]]
+        delegate_to receiver
+      rescue => ε
+        → ({ error: ε }),
+            { status: 500, headers:
+              { "X-Message" => "[...] from a problem to the accidents that condition and resolve it." } }
       end
 
+      # Define routes in the application
       def route(verb, path, &blk)
         meta_def(conjugate(verb, path)) { instance_eval &blk }
       end
 
-      def call(e)
-        @request  = Request.new e["REQUEST_METHOD"].downcase, e["PATH_INFO"], I[e["rack.input"].read]
-        @params   = ascertain receiver, @request.path
+      # Render responses
+      def render(body=:ok, options={})
+        options.reverse_merge!({ status: 200 })
 
-        send receiver
-      rescue => ε
-        # [...] from a problem to the accidents that condition and resolve it.
-        self >> { error: ε }
+        options[:headers] ||= {}
+        options[:headers].reverse_merge!({
+          "Content-Type" => "text/json", "X-Framework" => "Immanence" })
+
+        Rack::Response.new(O[body], options[:status], options[:headers]).finish
       end
 
+      alias_method :→, :render
+
     private
 
       def conjugate(verb, path) # :nodoc:
         "immanent_#{verb}_#{path}"
       end
 
-      # @return [Hash] Hash of request parameters
+      # @return [Hash] Hash of parameters gleaned from request signature
       def ascertain(method, path)
         [method.to_s.gsub(/immanent_\w*_/, ""), path].
 
         map     { |path| path.split("/")[1..-1] }.
         let     { |x, y| x.zip(y) }.
-        select  { |x, y| x[0] == ":" }.
+        select  { |x, _| x[0] == ":" }.
         map     { |x, y| { x[1..-1] => y } }.
 
         reduce({}, :merge).
@@ -88,9 +109,11 @@ module Immanence
       # @return [String] most likely candidate method to invoke based on incoming route
       def receiver
         @receiver ||= methods.grep(/immanent_/).map { |method|
-          { method: method, Δ: LEVENSHTEIN[method, conjugate(@request.verb, @request.path)] }
+          { method: method, Δ: LEVENSHTEIN[method, conjugate(request.request_method, request.path)] }
         }.min_by { |x| x[:Δ] }[:method]
       end
-    end
-  end
-end
+    end # self
+  end # Control
+end # Immanence
+
+Immanent = Immanence

data/lib/immanence/version.rb

@@ -1,3 +1,3 @@
 module Immanence
-  VERSION = "0.0.2"
+  VERSION = "0.1.1"
 end

data/spec/immanence_spec.rb

@@ -0,0 +1,49 @@
+# encoding: UTF-8
+
+require File.expand_path(File.dirname(__FILE__) + "/spec_helper")
+
+describe "Immanent" do
+  before do
+    class Application < Immanent::Control
+      route :get, "/resource/:id" do
+        render ({ no: :future })
+      end
+    end
+  end
+
+  it "should calculate the Levenshtein difference between two strings (0)" do
+    Immanent::Control::LEVENSHTEIN["kitten", "sitten"].should eq 1
+  end
+
+  it "should calculate the Levenshtein difference between two strings (1)" do
+    Immanent::Control::LEVENSHTEIN["sitten", "sittin"].should eq 1
+  end
+
+  it "should calculate the Levenshtein difference between two strings (2)" do
+    Immanent::Control::LEVENSHTEIN["sittin", "sitting"].should eq 1
+  end
+
+  it "should conjugate a verb and path into a method name" do
+    Immanent::Control.send(:conjugate, :get, "/resource/:id").should eq "immanent_get_/resource/:id"
+  end
+
+  it "should extract parameters out of the request path" do
+    Immanent::Control.send(:ascertain, "immanent_get_/resource/:id", "/resource/1000").should eq({ id: "1000" })
+  end
+
+  it "should be able to extract multiple parameters out of the request path" do
+    Immanent::Control.send(:ascertain, "immanent_get_/resource/:resource_id/child/:id", "/resource/1000/child/10").should eq({ resource_id: "1000", id: "10" })
+  end
+
+  it "should provide a DSL for defining routes" do
+    Application.methods.include?(:"immanent_get_/resource/:id").should be_true
+  end
+
+  it "should have a default response" do
+    Application.render[0].should eq(Rack::Response.new("\"ok\"").finish[0])
+  end
+
+  it "should respond with the route definition, a JSON string" do
+    Application.send("immanent_get_/resource/:id").last.body.should eq(["{\"no\":\"future\"}"])
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+require "rspec"
+
+require "./lib/immanence"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: immanence
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.1
 platform: ruby
 authors:
 - dzucconi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-25 00:00:00.000000000 Z
+date: 2013-08-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -97,6 +97,8 @@ files:
 - lib/core_ext/object.rb
 - lib/immanence.rb
 - lib/immanence/version.rb
+- spec/immanence_spec.rb
+- spec/spec_helper.rb
 homepage: http://github.com/dzucconi/immanence
 licenses:
 - CC0
@@ -121,5 +123,7 @@ rubygems_version: 2.0.6
 signing_key: 
 specification_version: 4
 summary: A framework
-test_files: []
+test_files:
+- spec/immanence_spec.rb
+- spec/spec_helper.rb
 has_rdoc: