middleman-router 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 979526ec50e8d23d348acf97ea76b08f39560897
+  data.tar.gz: 6d39307fdd6ec98bf6cadfc5738f471399aece69
+SHA512:
+  metadata.gz: 37453c7dbd4cfe26a2236d32f6dce387c7d1aa0ecbf105818138e60c8287884aa129f345846481b03b143f72531553fa012c9ae1d26a3eebf325c1f921c0d4e1
+  data.tar.gz: ced32ec7694de15389c600ec729cbbdb4d7287900c98ae7a81c572a63a91a0f58bbe28c53551b8cdd6d09de6b7480786d9e7127e2119f27ef846e14e90e76215

data/.gitignore

@@ -0,0 +1,10 @@
+# Ignore bundler lock file
+/Gemfile.lock
+
+# Ignore pkg folder
+/pkg
+
+/.ruby-version
+/.ruby-gemset
+
+*.gem

data/Gemfile

@@ -0,0 +1,18 @@
+# If you do not have OpenSSL installed, update
+# the following line to use "http://" instead
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in middleman-router.gemspec
+gemspec
+
+group :development do
+  gem 'rake'
+  gem 'rdoc'
+  gem 'yard'
+end
+
+group :test do
+  gem 'cucumber'
+  gem 'aruba'
+  gem 'rspec'
+end

data/README.md

@@ -0,0 +1,188 @@
+# Middleman Router
+
+`middleman-router` is an extension of Middleman that provides an easy way to organize and manage all of your page routes.
+
+## Install
+
+Add this line to your application's Gemfile:
+
+```
+gem 'middleman-router'
+```
+
+And then execute:
+
+```
+$ bundle install
+```
+
+Or install it yourself as:
+
+```
+$ gem install middleman-robots
+```
+
+Activate the plugin in the config.rb file
+
+```
+# config.rb
+activate :router
+```
+
+By default, your routes should be stored in `lib/routes.rb` but you can customize the location if you'd like:
+
+```
+# config.rb
+activate :router, routes_location: 'routes/routes'
+```
+
+## Defining Your Routes
+
+In order to use Middlman Router, you need to setup your routes files.
+
+```ruby
+# lib/routes.rb
+Router.draw do
+  route :home, path: ""
+  route :about
+  route :contact
+
+  route :services do
+    route :strategy, path: "digital-strategy"
+    route :design
+    route :development, path: "web-development"
+    route :search
+  end
+
+  route :careers, url: "https://external-link.jobboard.com"
+end
+```
+
+## Using Routes
+
+Once you've defined all of your routes in your routes file, you can easily call any named route by using the helper. If you have a named route of `route :about` then you can simply call:
+
+```ruby
+= link_to "About Us", Router.about_path
+```
+
+When the site is compiled, it will render the URL from your route. If you change a route within your routes file then there is no need to change the route helper declaration unless you change the named route (e.g. you changed `route :about` to `route :about_us`.
+
+For nested routes, you'll need to use the parent named route as part of the path, e.g.:
+
+```ruby
+# lib/routes.rb
+route :about do
+  route :team
+end
+
+# html/erb file
+= link_to "Team", Router.team_about_path
+```
+
+## Route Attributes
+
+Defining a `route` is the base for creating a new route. There are a few options you can pass to `route` to customize it.
+
+**name**
+The name of the route is the only required attribute.
+
+```ruby
+route :about_us
+```
+
+This will create a route like `about_us` and point to the file `about_us.html`.
+
+**path**
+You can customize the file that a give route loads. This is useful if you prefer hypenated urls rather than snake case.
+
+```ruby
+route :about_us, path: "about-us"
+```
+
+This will look for a file `about-us.html` for the given route. You can point any route to whatever file or directory that you want.
+
+```ruby
+route :about_us, path: "about/about-company"
+```
+**url**
+You can have routes that link to external endpoints, simple add the `url` attribute to your route:
+
+```ruby
+route :client_login, url: "https://link-to-external-site.com"
+```
+
+**Nested Paths**
+You can easily nest paths by adding additional routes to a route block. For example:
+
+```ruby
+route :about do
+  route :team
+  route :history
+  route :location
+end
+```
+
+This will create the following routes:
+
+- /about
+- /about/team
+- /about/history
+- /about/location
+
+You can continue to nest if you'd like.
+
+```ruby
+route :about do
+  route :team do
+    route :bob
+    route :sally do
+      route :bio
+      route :experience
+    end
+  end
+end
+```
+
+This will create the following routes:
+
+- /about
+- /about/team
+- /about/team/bob
+- /about/team/sally
+- /about/team/sally/bio
+- /about/team/sally/experience
+
+
+**index**
+If you want to nest pages but don't want an index route then you can exlude that from the route generation.
+
+```ruby
+route :service, index: false do
+  route :design
+  route :development
+end
+```
+
+This will avoid trying to match the url `/services` to `services/index.html`. This is useful wen you don't have index files for a subdirectory.
+
+
+**query params**
+You can pass query params to any route like you do with the rails router. Simple pass the query key and value as a hash to the route.
+
+```ruby
+= link_to "Contact Us", contact_path(ref: "work", location: "header")
+#=> /contact?ref=work&location=header
+```
+
+## Things to note
+
+One thing to note is that the index root needs to be setup like this:
+
+```ruby
+Router.draw do
+  route :home, path: ""
+end
+```
+
+Otherwise, it'll try to route `Router.home_path` to `home.html`.

data/Rakefile

@@ -0,0 +1,14 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'cucumber/rake/task'
+
+Cucumber::Rake::Task.new(:cucumber, 'Run features that should pass') do |t|
+  t.cucumber_opts = '--color --tags ~@wip --strict'
+end
+
+require 'rake/clean'
+
+task test: ['cucumber']
+
+task default: :test

data/features/support/env.rb

@@ -0,0 +1,4 @@
+PROJECT_ROOT_PATH = File.dirname(File.dirname(File.dirname(__FILE__)))
+require 'middleman-core'
+require 'middleman-core/step_definitions'
+require File.join(PROJECT_ROOT_PATH, 'lib', 'middleman-router')

data/lib/middleman-router.rb

@@ -0,0 +1,6 @@
+require "middleman-core"
+
+Middleman::Extensions.register(:router) do
+  require "middleman-router/extension"
+  Router
+end

data/lib/middleman-router/extension.rb

@@ -0,0 +1,58 @@
+# Require core library
+require 'middleman-core'
+require 'middleman-router/mapper'
+
+# TODO
+# -[ ] Auto reload the routes when they are updated
+# -[ ] Need ability to add `root_path` which defaults to index.html
+# -[ ] index: false should work
+# -[ ] Refactor so "Router.path_name" is not required, only 'path_name'
+# -[ ] Ability to print out all routes, e.g. `rake routes`
+# -[ ] Ability to add "/" at the end of each route
+
+# Extension namespace
+class Router < ::Middleman::Extension
+  option :routes_location, 'lib/routes'
+
+  @app = nil
+
+  def initialize(app, options_hash={}, &block)
+    super
+
+    @app = app
+    require options.routes_location
+  end
+
+  def after_configuration
+    # Do something
+  end
+
+  class << self
+    def draw(&block)
+      mapper = Mapper.new(self)
+      mapper.instance_exec(&block)
+      nil
+    end
+
+    def add_route(path_name, path_url)
+      puts "#{path_name} => #{path_url}"
+      define_singleton_method(path_name) do |*args|
+        url(path_url, args.first)
+      end
+
+      self.expose_to_template << path_name
+    end
+
+    private
+
+    def url(path, *args)
+      options = args.first
+
+      if options
+        path = "#{path}?#{options.to_query}"
+      end
+
+      path
+    end
+  end
+end

data/lib/middleman-router/mapper.rb

@@ -0,0 +1,132 @@
+class Mapper
+  # A Resource class for a route. Basically just a way
+  # to hold data for a route
+  class Resource
+    attr_accessor :name, :route_name, :path, :enabled
+
+    def initialize(options={})
+      @name       = options[:name]
+      @route_name = options[:route_name]
+      @path       = options[:path]
+      @enabled    = options[:enabled]
+    end
+
+    def enabled?
+      @enabled == true
+    end
+  end
+
+  # Initialize the Mapper
+  def initialize(set)
+    @set = set
+    @resources = []
+  end
+
+  # Route
+  # Creates a new route and any child routes
+  #
+  # Usage: route :about_us, path: "about-us", as: "about"
+  def route(*args, &block)
+    resource = build_resource(args, @scope)
+
+    if resource.enabled?
+      @set.add_route(resource.route_name, resource.path)
+    end
+
+    # If a block is passed, then let's create routes
+    # for each child route in the block
+    #
+    if block_given?
+      previous_scope = @scope
+      @scope = resource
+
+      self.instance_exec(&block)
+
+      @scope = previous_scope
+    end
+  end
+
+  private
+
+  # Create a Resource for the route
+  def build_resource(args, scope=nil)
+    options         = args.last.is_a?(::Hash) ? args.pop : {}
+    options[:scope] = scope if scope
+    enabled         = !(options[:index] == false)
+    route           = args.first
+
+    # Set the route attributes, name, path, etc
+    name       = named(route, options)
+    route_name = named_route(route, options)
+    path       = url_route(route, options)
+
+    # Create and return the route resource
+    Resource.new(
+      name:       name,
+      route_name: route_name,
+      path:       path,
+      enabled:    enabled
+    )
+  end
+
+  # Returns the named_route that can be access as a
+  # global helper on the front-end
+  def named_route(route_name, options={})
+    label = named(route_name, options)
+    # Return it as a underscored symbol
+    "#{label}_path".underscore.to_sym
+  end
+
+  def named(route_name, options={})
+    # User can override the name
+    if options[:as]
+      route_name = options[:as]
+    end
+
+    # If there is a parent/scope, then let's prepend
+    # that route to the named_route
+    if options[:scope]
+      route_name = "#{route_name}_#{options[:scope].name}"
+    end
+
+    route_name
+  end
+
+  # Return the URL fro the route
+  def url_route(route_name, options={})
+    if options[:url]
+      return options[:url]
+    end
+
+    # Ability to customize this
+    if options[:path]
+      if options[:path].empty?
+        return "/"
+      else
+        path = options[:path]
+      end
+    else
+      path = route_name
+    end
+
+    # Nest under a parent/scope route if required
+    if options[:scope]
+      path = "#{options[:scope].path}#{parameterize(path)}"
+    else
+      path = "/#{parameterize(path)}"
+    end
+
+    "#{path}/"
+  end
+
+  # Parameterize a string
+  def parameterize(string)
+    string = string.to_s
+
+    # Turn unwanted chars into the separator.
+    string.gsub!(/[^a-z0-9\-_]+/i, '-')
+    string.downcase!
+
+    string
+  end
+end

data/lib/middleman_extension.rb

@@ -0,0 +1 @@
+require 'middleman-router'

data/middleman-router.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "middleman-router"
+  s.version     = "0.0.1"
+  s.licenses    = ['MIT']
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["John Koht"]
+  s.email       = ["john@kohactive.com"]
+  s.homepage    = "https://github.com/kohactive/middleman-router"
+  s.summary     = %q{A simple router for Middleman projects}
+  s.description = %q{A simple router for Middleman projets, inspired by the Rails router}
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # The version of middleman-core your extension depends on
+  s.add_runtime_dependency("middleman-core", '~> 4.2', '>= 4.2.1')
+
+  # Additional dependencies
+  # s.add_runtime_dependency("gem-name", "gem-version")
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification
+name: middleman-router
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- John Koht
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-07-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: middleman-core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.2.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.2.1
+description: A simple router for Middleman projets, inspired by the Rails router
+email:
+- john@kohactive.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- README.md
+- Rakefile
+- features/support/env.rb
+- lib/middleman-router.rb
+- lib/middleman-router/extension.rb
+- lib/middleman-router/mapper.rb
+- lib/middleman_extension.rb
+- middleman-router.gemspec
+homepage: https://github.com/kohactive/middleman-router
+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.6.11
+signing_key: 
+specification_version: 4
+summary: A simple router for Middleman projects
+test_files:
+- features/support/env.rb