hart 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0e2f4a971dd9e107927c8c5773c11fe9ddad051f
+  data.tar.gz: a0c803538d828027597f92fb858e8fd6ec045196
+SHA512:
+  metadata.gz: 5a3edcbd23fc68ef7e909f9519867de831d4d91e9faff7e87f71f393977b107922e350f028c15e100a01a89ec8aaea52ecfcfbe312776c9480a944e7d919a4ac
+  data.tar.gz: e9b7d0b13c984f6b683893326eccd32b400d71dbbd243ec0c6e388d6630e09f409745f653ab155a1d64a5a661bfff28e29f3ad3fd707e5c1a9eb815a1292f130

data/.gems

@@ -0,0 +1,3 @@
+rack-test -v 0.6.3
+cutest -v 1.2.2
+seg -v 0.0.1

data/CONTRIBUTING

@@ -0,0 +1,19 @@
+This code tries to solve a particular problem with a very simple
+implementation. We try to keep the code to a minimum while making
+it as clear as possible. The design is very likely finished, and
+if some feature is missing it is possible that it was left out on
+purpose. That said, new usage patterns may arise, and when that
+happens we are ready to adapt if necessary.
+
+A good first step for contributing is to meet us on IRC and discuss
+ideas. We spend a lot of time on #lesscode at freenode, always ready
+to talk about code and simplicity. If connecting to IRC is not an
+option, you can create an issue explaining the proposed change and
+a use case. We pay a lot of attention to use cases, because our
+goal is to keep the code base simple. Usually the result of a
+conversation is the creation of a different tool.
+
+Please don't start the conversation with a pull request. The code
+should come at last, and even though it may help to convey an idea,
+more often than not it draws the attention to a particular
+implementation.

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2015 Michel Martens
+
+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,164 @@
+Hart
+====
+
+Hash router
+
+Description
+-----------
+
+Hart is a generic routing library that walks a hash and detects
+matches according to a given pair of verb and path arguments.
+
+Usage
+-----
+
+A basic example would look like this:
+
+```ruby
+words = {
+  "c" => {
+    "o" => {
+      "d" => {
+        define: "A husk; a pod; as, a peascod.",
+
+        "a" => {
+          define: "Concluding passage of a piece or movement."
+        },
+
+        "e" => {
+          define: "System of rules relating to one subject.",
+
+          "c" => {
+            define: "Device that compresses and decompresses data."
+          },
+
+          "x" => {
+            define: "A book; a manuscript."
+          }
+        }
+      }
+    }
+  }
+}
+
+h = Hart.new(routes)
+h.call(:define, "/c/o/d")     #=> "A husk; a pod; as, a peascod."
+h.call(:define, "/c/o/d/e")   #=> "System of rules relating to one subject."
+h.call(:define, "/c/o/d/e/r") #=> nil
+```
+
+The `call` method accepts two arguments: a verb, which must be a
+symbol, and a path, which must be a string in the form `"/a/b/c"`.
+
+It is possible to define more than one verb per element:
+
+```ruby
+countries = {
+  "argentina" => {
+    population: 43_417_000,
+    area: 2_780_400,
+  },
+
+  "france" => {
+    population: 66_200_000,
+    area: 640_679,
+  }
+}
+
+h = Hart.new(countries)
+h.call(:population, "/argentina") #=> 43417000
+h.call(:population, "/france")    #=> 66200000
+h.call(:area,       "/argentina") #=>  2780400
+h.call(:area,       "/france")    #=>   640679
+```
+
+The default value for a miss can be configured as follows:
+
+```ruby
+countries[:default] = "Country not found."
+```
+
+After adding that key to the previous example, any miss will return
+the string `"Country not found."`.
+
+```ruby
+h.call(:population, "/foobar") #=> "Country not found."
+```
+
+The value of each entry can be anything that responds to `[](key)`.
+For instance, a `proc` could be used:
+
+```ruby
+countries["peru"] = proc { |key|
+  case key
+  when :population
+    30_400_000
+  when :area
+    1_285_216
+  else
+    nil
+  end
+}
+
+h.call(:population, "/peru") #=> 30400000
+```
+
+If the special symbol `:id` is present as an element, it will match
+any path segment in that position, given that no other matches
+occurred.
+
+```ruby
+countries[:id] = proc { |key|
+  "No information about #{key}"
+}
+
+h.call(:area, "/foobar") #=> "No information about foobar"
+```
+
+The next example combines all the concepts explained so far, and
+shows how to match HTTP requests based on `REQUEST_METHOD` and
+`PATH_INFO`.
+
+```ruby
+routes = {
+  default: [404, {}, ["Not Found"]],
+
+  GET: [200, {}, ["GET /"]],
+
+  "foo" => {
+    "bar" => {
+      GET: [200, {}, ["GET /foo/bar"]],
+      PUT: [200, {}, ["PUT /foo/bar"]],
+    }
+  },
+
+  "users" => {
+    GET: [200, {}, ["GET /posts"]],
+
+    id: proc { |id|
+      {
+        GET: [200, {}, ["GET /users/#{id}"]],
+      }
+    }
+  }
+}
+
+h = Hart.new(routes)
+h.call(:GET, "/foo/bar")  #=> [200, {}, ["GET /foo/bar"]]
+h.call(:PUT, "/foo/bar")  #=> [200, {}, ["PUT /foo/bar"]]
+h.call(:GET, "/users/42") #=> [200, {}, ["GET /users/42"]]
+h.call(:GET, "/baz")      #=> [404, {}, ["Not Found"]]
+```
+
+API
+---
+
+`call`: Accepts two arguments: a verb, which must be a symbol, and
+a path, which must be a string in the form `"/a/b/c"`.
+
+Installation
+------------
+
+```
+$ gem install hart
+```

data/hart.gemspec

@@ -0,0 +1,16 @@
+Gem::Specification.new do |s|
+  s.name              = "hart"
+  s.version           = "0.0.1"
+  s.summary           = "Hash routing"
+  s.description       = "Hash routing"
+  s.authors           = ["Michel Martens"]
+  s.email             = ["michel@soveran.com"]
+  s.homepage          = "https://github.com/soveran/hart"
+  s.license           = "MIT"
+
+  s.files = `git ls-files`.split("\n")
+
+  s.add_dependency "seg"
+  s.add_development_dependency "cutest"
+  s.add_development_dependency "rack-test"
+end

data/lib/hart.rb

@@ -0,0 +1,50 @@
+# encoding: UTF-8
+#
+# Copyright (c) 2015 Michel Martens
+#
+# 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.
+
+require "seg"
+
+class Hart
+  attr_reader :routes
+
+  def initialize(routes)
+    @routes = routes
+  end
+
+  def call(verb, path)
+    seg = Seg.new(path)
+
+    inbox = {}
+    route = @routes
+
+    while seg.capture(:segment, inbox)
+      route = route[inbox[:segment]] ||
+              route[:id] && route[:id][inbox[:segment]]
+      break if route.nil?
+    end
+
+    if route
+      route[verb.intern]
+    else
+      routes[:default]
+    end
+  end
+end

data/makefile

@@ -0,0 +1,4 @@
+.PHONY: test
+
+test:
+	cutest -r ./test/helper.rb ./test/*.rb

data/test/all.rb

@@ -0,0 +1,139 @@
+scope "generic routing" do
+  peru = proc { |key|
+    case key
+    when :population
+      30_400_000
+    when :area
+      1_285_216
+    else
+      nil
+    end
+  }
+
+  @words = {
+    "peru" => peru,
+    "c" => {
+      "o" => {
+        "d" => {
+          define: "A husk; a pod; as, a peascod.",
+
+          "a" => {
+            define: "Concluding passage of a piece or movement."
+          },
+
+          "e" => {
+            define: "System of rules relating to one subject.",
+
+            "c" => {
+              define: "Device that compresses and decompresses data."
+            },
+
+            "x" => {
+              define: "A book; a manuscript."
+            }
+          }
+        }
+      }
+    }
+  }
+
+  setup do
+    Hart.new(@words)
+  end
+
+  test do |h|
+    definition = h.call(:population, "/peru")
+    assert_equal definition, 30400000
+
+    definition = h.call(:define, "/c/o/d")
+    assert_equal definition, "A husk; a pod; as, a peascod."
+
+    definition = h.call(:define, "/c/o/d/a")
+    assert_equal definition, "Concluding passage of a piece or movement."
+
+    definition = h.call(:define, "/c/o/d/e")
+    assert_equal definition, "System of rules relating to one subject."
+
+    definition = h.call(:define, "/c/o/d/e/c")
+    assert_equal definition, "Device that compresses and decompresses data."
+
+    definition = h.call(:define, "/c/o/d/e/x")
+    assert_equal definition, "A book; a manuscript."
+
+    definition = h.call(:define, "/c/o/d/e/r")
+    assert_equal definition, nil
+  end
+end
+
+scope "routing HTTP requests" do
+
+  class HartWrapper
+    PATH_INFO      = "PATH_INFO".freeze
+    REQUEST_METHOD = "REQUEST_METHOD".freeze
+
+    def initialize(hart)
+      @hart = hart
+    end
+
+    def call(env)
+      @hart.call(env.fetch(REQUEST_METHOD), env.fetch(PATH_INFO))
+    end
+  end
+
+  @routes = {
+    default: [404, {}, [""]],
+
+    GET: [200, {}, ["GET /"]],
+
+    "foo" => {
+      "bar" => {
+        GET: [200, {}, ["GET /foo/bar"]],
+        PUT: [200, {}, ["PUT /foo/bar"]],
+      }
+    },
+
+    "users" => {
+      GET: [200, {}, ["GET /posts"]],
+
+      id: proc { |id|
+        {
+          GET: [200, {}, ["GET /users/#{id}"]],
+        }
+      }
+    }
+  }
+
+  app = HartWrapper.new(Hart.new(@routes))
+
+  setup do
+    Driver.new(app)
+  end
+
+  test "path + verb" do |f|
+    f.get("/foo/bar")
+    assert_equal 200, f.last_response.status
+    assert_equal "GET /foo/bar", f.last_response.body
+
+    f.put("/foo/bar")
+    assert_equal 200, f.last_response.status
+    assert_equal "PUT /foo/bar", f.last_response.body
+  end
+
+  test "verbs match only on root" do |f|
+    f.get("/bar/baz/foo")
+    assert_equal "", f.last_response.body
+    assert_equal 404, f.last_response.status
+  end
+
+  test "root" do |f|
+    f.get("/")
+    assert_equal "GET /", f.last_response.body
+    assert_equal 200, f.last_response.status
+  end
+
+  test "captures" do |f|
+    f.get("/users/42")
+    assert_equal "GET /users/42", f.last_response.body
+    assert_equal 200, f.last_response.status
+  end
+end

data/test/helper.rb

@@ -0,0 +1,15 @@
+require_relative "../lib/hart"
+require "rack/test"
+
+class Driver
+  include Rack::Test::Methods
+
+  def initialize(app)
+    @app = app
+  end
+
+  def app
+    @app
+  end
+end
+

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification
+name: hart
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Michel Martens
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-12-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: seg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: cutest
+  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: rack-test
+  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'
+description: Hash routing
+email:
+- michel@soveran.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gems"
+- CHANGELOG
+- CONTRIBUTING
+- LICENSE
+- README.md
+- hart.gemspec
+- lib/hart.rb
+- makefile
+- test/all.rb
+- test/helper.rb
+homepage: https://github.com/soveran/hart
+licenses:
+- MIT
+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: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5.1
+signing_key: 
+specification_version: 4
+summary: Hash routing
+test_files: []