usmu 0.1.0-java

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 726f831d3d6e597914f648fc22e0fc20186da395
+  data.tar.gz: 5b1512b73c9bb120edbdafde348ee584d30a60c8
+SHA512:
+  metadata.gz: cc8ef55cd3f4ec4746ad2426a3e82e1de1d5956dcfa8ab0b5dc8ed908c945723a4306d58c4af2dd84f76e8ae124b5ba5c5b561223fb4a8907070b46237e66a96
+  data.tar.gz: 8727555906c5a1093e8107983685e899da7fd2a66a897fff5fba7462e49fe59bcc4477b5e02e196e0dc9f1e750642efe242cfa1c52efc8fa277a34b7847d420a

data/.cane

@@ -0,0 +1,4 @@
+--color
+--max-violations 0
+--style-measure 120
+--abc-exclude Usmu::Layout#initialize

data/.gitignore

@@ -0,0 +1,17 @@
+/.bundle/
+/.yardoc
+/Gemfile*.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+
+# Generated test site
+/test/site/site

data/.rspec

@@ -0,0 +1,5 @@
+--color
+-I test/spec
+--require spec_helper
+--format documentation
+--no-profile

data/.travis.yml

@@ -0,0 +1,34 @@
+language: ruby
+script: rake ci
+rvm:
+  - 2.0
+  - 2.1
+  - ruby-head
+  - jruby-19mode
+  - jruby-head
+  - rbx-2
+  - rbx-head
+gemfile:
+  - Gemfile
+  - Gemfile-jruby
+matrix:
+  exclude:
+    - rvm: 2.0
+      gemfile: Gemfile-jruby
+    - rvm: 2.1
+      gemfile: Gemfile-jruby
+    - rvm: ruby-head
+      gemfile: Gemfile-jruby
+    - rvm: jruby-19mode
+      gemfile: Gemfile
+    - rvm: jruby-head
+      gemfile: Gemfile
+    - rvm: rbx-2
+      gemfile: Gemfile-jruby
+    - rvm: rbx-head
+      gemfile: Gemfile-jruby
+  allow_failures:
+    - rvm: jruby-19mode
+    - rvm: jruby-head
+    - rvm: rbx-2
+    - rvm: rbx-head

data/.yardopts

@@ -0,0 +1 @@
+--private --protected --hide-void-return -m markdown -M redcarpet lib/**/*.rb - README.md

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in usmu.gemspec
+gemspec name: 'usmu'

data/Gemfile-jruby

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in usmu.gemspec
+gemspec name: 'usmu-jruby'

data/LICENSE.md

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Matthew Scharley and contributors
+
+MIT License
+
+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,50 @@
+# usmu [![Build Status](https://travis-ci.org/usmu/usmu.svg?branch=master)](https://travis-ci.org/usmu/usmu)
+
+**Source:** [https://github.com/usmu/usmu](https://github.com/usmu/usmu)  
+**Author:** Matthew Scharley  
+**Contributors:** [See contributors on GitHub][gh-contrib]  
+**Bugs/Support:** [Github Issues][gh-issues]  
+**Copyright:** 2014  
+**License:** [MIT license][license]  
+**Status:** Active
+
+## Synopsis
+
+`usmu` is a static site generator intended to be used with the future Rails-based editing platform. It can also be used
+to generate locally if you don't wish to use the web-based editor.
+
+## Installation
+
+    $ gem install usmu
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Compatibility
+
+As a baseline `usmu` will pull in Slim for layouts and Redcarpet for content written in Markdown. However we use the
+Tilt API to render all layouts and content, therefore you should be able to use anything supported by Tilt including
+Sass, Less, Textile and [many others][tilt-support], you just need to ensure you have the correct gems installed.
+
+If you want to further [configure the way your template's are processed][template-options] then you can specify 
+configurations for each template engine. Just add it to your `usmu.yml`:
+
+```yaml
+slim:
+  :pretty: true
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request
+
+  [gh-contrib]: https://github.com/usmu/usmu/graphs/contributors
+  [gh-issues]: https://github.com/usmu/usmu/issues
+  [license]: https://github.com/usmu/usmu/blob/master/LICENSE.md
+  [tilt-support]: https://github.com/rtomayko/tilt/blob/master/README.md
+  [template-options]: https://github.com/rtomayko/tilt/blob/master/docs/TEMPLATES.md

data/Rakefile

@@ -0,0 +1,61 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'rspec/core/rake_task'
+require 'cucumber'
+require 'cucumber/rake/task'
+require 'usmu/version'
+
+def current_gems
+  Dir["pkg/usmu-#{Usmu::VERSION}*.gem"]
+end
+
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.pattern = 'test/spec/**/*_spec.rb'
+end
+
+Cucumber::Rake::Task.new(:features) do |t|
+  t.cucumber_opts = 'test/features'
+end
+
+desc 'Run all test scripts'
+task :test => [:clean, :spec, :features]
+
+desc 'Run CI test suite'
+task :ci => [:test]
+
+desc 'Clean up after tests'
+task :clean do
+  rm_r 'test/site/site' if File.exist? 'test/site/site'
+  current_gems.each {|f| rm f }
+end
+
+namespace :gem do
+  desc 'Build gems'
+  task :build => [:clean] do
+    mkdir 'pkg' unless File.exist? 'pkg'
+    Dir['*.gemspec'].each do |gemspec|
+      sh "gem build #{gemspec}"
+    end
+    Dir['*.gem'].each do |gem|
+      mv gem, "pkg/#{gem}"
+    end
+  end
+
+  desc 'Install gem'
+  task :install => ['gem:build'] do
+    if RUBY_PLATFORM == 'java'
+      sh "gem install pkg/usmu-#{Usmu::VERSION}-java.gem"
+    else
+      sh "gem install pkg/usmu-#{Usmu::VERSION}.gem"
+    end
+  end
+
+  desc 'Deploy gems to rubygems'
+  task :deploy => ['gem:build'] do
+    current_gems.each do |gem|
+      sh "gem push #{gem}"
+    end
+    sh "git tag #{Usmu::VERSION}" if File.exist? '.git'
+  end
+end

data/bin/usmu

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+begin
+  require 'usmu/ui/console'
+rescue LoadError
+  $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+  require 'usmu/ui/console'
+end
+
+Usmu::Ui::Console.new(ARGV).execute

data/cucumber.yml

@@ -0,0 +1,2 @@
+---
+default: test/features --format pretty

data/lib/usmu/configuration.rb

@@ -0,0 +1,83 @@
+require 'yaml'
+
+module Usmu
+  # This class is used to represent a configuration file. This file should be a YAML file and called `usmu.yml`
+  # by default.
+  class Configuration
+    # @!attribute [r] config_file
+    # @return [String] the name of the file used to load the configuration.
+    attr_reader :config_file
+    # @!attribute [r] config_file
+    # @return [String] the folder that the configuration was loaded from.
+    attr_reader :config_dir
+
+    # Load a configuration from a YAML file on disk.
+    #
+    # @return [Usmu::Configuration]
+    def self.from_file(filename)
+      from_hash(YAML.load_file(filename), filename)
+    end
+
+    # Load a configuration from a hash.
+    #
+    # @return [Usmu::Configuration]
+    def self.from_hash(hash, config_path = nil)
+      self.new(hash, config_path)
+    end
+
+    # @!attribute [r] source_path
+    # @return [String] the full path to the source folder
+    def source_path
+      get_path @config['source'] || 'src'
+    end
+
+    # @!attribute [r] destination_path
+    # @return [String] the full path to the destination folder
+    def destination_path
+      get_path @config['destination'] || 'site'
+    end
+
+    # @!attribute [r] layouts_path
+    # @return [String] the full path to the layouts folder
+    def layouts_path
+      get_path @config['layouts'] || 'layouts'
+    end
+
+    # An index accessor to directly access the configuration file. It should be noted that `['source']` and
+    # `#source_path` and other similar pairs will have different values. `['source']` is the raw value from the
+    # configuration file while the latter is a path on the system, potentially altered by the path from the current
+    # working directory to the configuration file and other factors. The accessor functions such as `#source_path`
+    # should be preferred for most usages.
+    #
+    # @param [String, Symbol] index The index to return.
+    # @return [Array, Hash, String, Symbol] Returns a value from the hash loaded from YAML. The type of value will
+    #   ultimately depend on the configuration file and the index provided.
+    def [](index)
+      @config[index]
+    end
+
+    private
+
+    # This class has a private constructor.
+    #
+    # @see Usmu::Configuration.from_file
+    # @see Usmu::Configuration.from_hash
+    def initialize(hash, config_path)
+      @config = hash
+      @config_file = config_path
+      @config_dir = config_path ? File.dirname(config_path) : nil
+    end
+
+    # Helper function to transform a relative path in the configuration file to a relative path from the current
+    # working directory.
+    #
+    # @return [String]
+    def get_path(path)
+      if @config_dir.nil?
+        path
+      else
+        File.join(@config_dir, path)
+      end
+    end
+  end
+end

data/lib/usmu/layout.rb

@@ -0,0 +1,166 @@
+require 'tilt'
+require 'deep_merge'
+require 'usmu/static_file'
+
+module Usmu
+  # Class to represent files templated with a Tilt library. Most of the custom rendering logic is contained here.
+  class Layout < StaticFile
+    # @!attribute [r] type
+    # @return [String] the type of file this is. This is used to determine which template engine to use.
+    attr_reader :type
+
+    # @param configuration [Usmu::Configuration] The configuration for the website we're generating.
+    # @param name [String] The name of the file in the source directory.
+    # @param type [String] The type of template to use with the file. Used for testing purposes.
+    # @param content [String] The content of the file. Used for testing purposes.
+    # @param metadata [String] The metadata for the file. Used for testing purposes.
+    def initialize(configuration, name, type = nil, content = nil, metadata = nil)
+      super(configuration, name)
+
+      if type.nil?
+        type = name.split('.').last
+        unless ::Tilt.default_mapping[type]
+          raise "Templates of type '#{type}' aren't currently supported by Tilt. " +
+                'Do you have the required gem installed?'
+        end
+      end
+      @type = type
+      path = File.join("#{content_path}", "#{name[0, name.length - type.length - 1]}")
+
+      if content.nil?
+        content = File.read("#{path}.#{type}")
+      end
+      @content = content
+
+      if metadata.nil?
+        meta_file = "#{path}.meta.yml"
+        metadata = if File.exist? meta_file
+          YAML.load_file(meta_file)
+        else
+          {}
+        end
+      end
+      @metadata = metadata
+
+      @parent = Layout.find_layout(configuration, metadata['layout'])
+    end
+
+    # @!attribute [r] metadata
+    # @return [Hash] the metadata associated with this layout.
+    #
+    # Returns the metadata associated with this layout.
+    #
+    # This will include any metadata from parent templates and default metadata
+    def metadata
+      if @parent.nil?
+        @metadata.deep_merge(@configuration['default meta'] || {})
+      else
+        @metadata.deep_merge(@parent.metadata)
+      end
+    end
+
+    # Renders the file with any templating language required and returns the result
+    #
+    # @param variables [Hash] Variables to be used in the template.
+    # @return [String] The rendered file.
+    def render(variables = {})
+      content = template_class.new("#{@name}.#{@type}", 1, @configuration[provider_name]) { @content }.
+          render(nil, get_variables(variables))
+      has_cr = content.index("\r")
+      content += (has_cr ? "\r\n" : "\n") if content[-1] != "\n"
+      if @parent.nil?
+        content
+      else
+        @parent.render({'content' => content})
+      end
+    end
+
+    # @!attribute [r] output_extension
+    # @return [String] the extension to use with the output file.
+    def output_extension
+      'html'
+    end
+
+    # @!attribute [r] output_filename
+    # @return [String] the filename to use in the output directory.
+    #
+    # Returns the filename to use for the output directory with any modifications to the input filename required.
+    def output_filename
+      @name[0..@name.rindex('.')] + output_extension
+    end
+
+    # Static method to create a layout for a given configuration by it's name if it exists. This differs from
+    # `#initialise` in that it allows different types of values to be supplied as the name and will not fail if name
+    # is nil
+    #
+    # @param configuration [Usmu::Configuration] The configuration to use for the search
+    # @param name [String]
+    #   If name is a string then search for a template with that name. Name here should not include
+    #   file extension, eg. body not body.slim. If name is not a string then it will be returned verbatim. This means
+    #   that name is nilable and can also be passed in as an Usmu::Layout already for testing purposes.
+    # @return [Usmu::Layout]
+    def self.find_layout(configuration, name)
+      if name.class.name == 'String'
+        Dir["#{configuration.layouts_path}/#{name}.*"].each do |f|
+          filename = File.basename(f)
+          if filename != "#{name}.meta.yml"
+            return new(configuration, f[(configuration.layouts_path.length + 1)..f.length])
+          end
+        end
+      else
+        name
+      end
+    end
+
+    # Tests if a given file is a valid Tilt template based on the filename.
+    #
+    # @param folder_type [String]
+    #   One of `"source"` or `"layout"` depending on where the template is in the source tree.
+    #   Not used by Usmu::Layout directly but intended to be available for future API.
+    # @param name [String] The filename to be tested.
+    # @return [Boolean]
+    def self.is_valid_file?(folder_type, name)
+      type = name.split('.').last
+      ::Tilt.default_mapping[type] ? true : false
+    end
+
+    protected
+
+    # @!attribute [r] template_class
+    # @return [Tilt::Template] the Tilt template engine for this layout
+    def template_class
+      @template_class ||= ::Tilt.default_mapping[@type]
+    end
+
+    # @!attribute [r] provider_name
+    # @return [String] the Tilt template engine's name for this layout
+    #
+    # Returns the Tilt template engine's name for this layout.
+    #
+    # This is used to determine which settings to use from the configuration file.
+    def provider_name
+      Tilt.default_mapping.lazy_map[@type].select {|x| x[0] == template_class.name }.first[1].split('/').last
+    end
+
+    # @!attribute [r] content_path
+    # @return [string] the base path to the files used by this class.
+    #
+    # Returns the base path to the files used by this class.
+    #
+    # This folder should be the parent folder for the file named by the name attribute.
+    #
+    # @see #name
+    def content_path
+      @configuration.layouts_path
+    end
+
+    private
+
+    # Utility function which collates variables to pass to the template engine.
+    #
+    # @return [Hash]
+    def get_variables(variables)
+      variables.deep_merge(metadata).deep_merge({site: @configuration})
+    end
+  end
+end

data/lib/usmu/page.rb

@@ -0,0 +1,19 @@
+
+module Usmu
+  # Represents a page in the source directory of the website.
+  class Page < Layout
+    protected
+
+    # @!attribute [r] content_path
+    # @return [string] the base path to the files used by this class.
+    #
+    # Returns the base path to the files used by this class.
+    #
+    # This folder should be the parent folder for the file named by the name attribute.
+    #
+    # @see #name
+    def content_path
+      @configuration.source_path
+    end
+  end
+end

data/lib/usmu/site_generator.rb

@@ -0,0 +1,82 @@
+require 'fileutils'
+
+module Usmu
+  # This is the class that brings everything together to generate a new website.
+  class SiteGenerator
+    # @param [Usmu::Configuration] configuration The configuration to use for generating the website
+    def initialize(configuration)
+      @configuration = configuration
+    end
+
+    # @!attribute [r] layouts
+    # @return [Array<Usmu::Layout>] a list of layouts available in this website.
+    def layouts
+      get_renderables @configuration.layouts_path, true
+    end
+
+    # @!attribute [r] renderables
+    # @return [Array<Usmu::StaticFile>] a list of renderable files from the source folder.
+    #   will be a subclass of this class.
+    # @see Usmu::StaticFile
+    #
+    # Returns a list of renderable files from the source folder.
+    #
+    # The only guarantee made for individual files is that they will conform to the interface defined by
+    # Usmu::StaticFile and thus be renderable, however most files will be one of the subclasses of that class.
+    def renderables
+      get_renderables @configuration.source_path, false
+    end
+
+    # @!attribute [r] pages
+    # @return [Array<Usmu::Page>] a list of pages from the source folder. This is any file in the source folder which
+    #   is not static.
+    def pages
+      renderables.select {|r| r.class.name != 'Usmu::StaticFile'}
+    end
+
+    # @!attribute [r] files
+    # @return [Array<Usmu::StaticFile>] a list of static files from the source folder.
+    def files
+      renderables.select {|r| r.class.name == 'Usmu::StaticFile'}
+    end
+
+    # Generate the website according to the configuration given.
+    #
+    # @return [void]
+    def generate
+      renderables.each do |page|
+        file = File.join(@configuration.destination_path, page.output_filename)
+        directory = File.dirname(file)
+
+        unless File.directory?(directory)
+          FileUtils.mkdir_p(directory)
+        end
+
+        File.write file, page.render
+      end
+      nil
+    end
+
+    private
+
+    # Helper function to search a directory recursively and return a list of files that are renderable.
+    #
+    # @param [String] directory the directory to search
+    # @param [Boolean] layout is this directory a layouts_path
+    # @return [Array<Usmu::Layout>, Array<Usmu::StaticFile>] Either an array of Layouts or StaticFiles in the directory
+    def get_renderables(directory, layout)
+      Dir["#{directory}/**/*"].select {|f| !f.match(/\.meta.yml$/) }.map do |f|
+        filename = f[(directory.length + 1)..f.length]
+        if layout
+          Usmu::Layout.new(@configuration, filename)
+        else
+          if Usmu::Layout.is_valid_file? 'source', filename
+            Usmu::Page.new(@configuration, filename)
+          else
+            Usmu::StaticFile.new(@configuration, filename)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/usmu/static_file.rb

@@ -0,0 +1,39 @@
+
+module Usmu
+  # Represents a static file which should be transferred to the destination unchanged. This also acts as the base
+  # class for all layouts and page types. The basic interface defined here is used to process all types of files.
+  class StaticFile
+    # @!attribute [r] name
+    # @return [String] the name of the file in the source directory
+    attr_reader :name
+
+    # @param configuration [Usmu::Configuration] The configuration for the website we're generating.
+    # @param name [String] The name of the file in the source directory.
+    # @param type [String] The type of template to use with the file. Not used for StaticFile.
+    #   Used for testing purposes.
+    # @param content [String] The content of the file. Used for testing purposes.
+    # @param metadata [String] The metadata for the file. Used for testing purposes.
+    def initialize(configuration, name, type = nil, content = nil, metadata = nil)
+      @configuration = configuration
+      @name = name
+      @type = type
+      @content = content
+    end
+
+    # Renders the file with any templating language required and returns the result
+    #
+    # @param variables [Hash] Variables to be used in the template.
+    # @return [String] The rendered file
+    def render(variables = {})
+      @content || File.read(File.join(@configuration.source_path, @name))
+    end
+
+    # @!attribute [r] output_filename
+    # @return [String] the filename to use in the output directory.
+    #
+    # Returns the filename to use for the output directory with any modifications to the input filename required.
+    def output_filename
+      @name
+    end
+  end
+end

data/lib/usmu/ui/console.rb

@@ -0,0 +1,26 @@
+require 'usmu'
+require 'trollop'
+
+module Usmu
+  module Ui
+    # This is the CLI UI controller. This is initialised by the usmu binary to control the generation process.
+    class Console
+      # @!attribute [r] configuration
+      # @return [Usmu::Configuration] the configuration for the site we will generate.
+      attr_reader :configuration
+
+      # @param [Array<String>] args Command line arguments. Typically ARGV should be passed here.
+      def initialize(args)
+        @args = args
+        @configuration = Usmu::Configuration.from_file(File.join(args[0] || '.', 'usmu.yml'))
+      end
+
+      # This will run the command as setup in `#initialize`
+      #
+      # @return [void]
+      def execute
+        Usmu::SiteGenerator.new(@configuration).generate
+      end
+    end
+  end
+end

data/lib/usmu/ui.rb

@@ -0,0 +1,7 @@
+require 'usmu'
+
+module Usmu
+  # This module is for all the different UI's. If you implement a custom UI it should be added here.
+  module Ui
+  end
+end

data/lib/usmu/version.rb

@@ -0,0 +1,5 @@
+
+module Usmu
+  # The current versions string for the gem
+  VERSION = '0.1.0'
+end