awestruct 0.0.3 → 0.0.4

data/lib/awestruct/engine.rb

@@ -16,6 +16,11 @@ require 'awestruct/haml_helpers'
 require 'awestruct/extensions/pipeline'
 require 'awestruct/extensions/posts'
 require 'awestruct/extensions/indexifier'
+require 'awestruct/extensions/paginator'
+require 'awestruct/extensions/atomizer'
+
+require 'awestruct/util/inflector'
+require 'awestruct/util/default_inflections'
 
 module Awestruct
 
@@ -29,6 +34,7 @@ module Awestruct
       @dir    = dir
       @config = config
       @site   = Site.new( @dir )
+      @site.engine = self
       @site.tmp_dir = File.join( dir, '_tmp' )
       FileUtils.mkdir_p( @site.tmp_dir )
       FileUtils.mkdir_p( @site.output_dir )
@@ -45,6 +51,44 @@ module Awestruct
       generate_files(force)
     end
 
+    def find_and_load_site_page(simple_path)
+      path_glob = File.join( dir, simple_path + '.*' )
+      candidates = Dir[ path_glob ]
+      return nil if candidates.empty?
+      throw Exception.new( "too many choices for #{simple_path}" ) if candidates.size != 1
+      dir_pathname = Pathname.new( dir )
+      path_name = Pathname.new( candidates[0] )
+      relative_path = path_name.relative_path_from( dir_pathname ).to_s
+      load_page( candidates[0], relative_path )
+    end
+
+    def load_site_page(relative_path)
+      load_page( File.join( dir, relative_path ) )
+    end
+
+    def load_page(path, relative_path=nil)
+      page = nil
+      if ( relative_path.nil? )
+        #dir_pathname = Pathname.new( dir )
+        #path_name = Pathname.new( path )
+        #relative_path = path_name.relative_path_from( dir_pathname ).to_s
+      end
+
+      fixed_relative_path = ( relative_path.nil? ? nil : File.join( '', relative_path ) )
+
+      if ( path =~ /\.haml$/ )
+        page = HamlFile.new( site, path, fixed_relative_path )
+      elsif ( path =~ /\.md$/ )
+        page = MarukuFile.new( site, path, fixed_relative_path )
+      elsif ( path =~ /\.sass$/ )
+        page = SassFile.new( site, path, fixed_relative_path )
+      elsif ( File.file?( path ) )
+        page = VerbatimFile.new( site, path, fixed_relative_path )
+      end
+      page
+    end
+
+
     private
 
     def set_urls
@@ -134,7 +178,8 @@ module Awestruct
         layout_pathname = Pathname.new( layout_path )
         relative_path = layout_pathname.relative_path_from( dir_pathname ).to_s
         name = File.basename( layout_path, '.haml' )
-        site.layouts[ name ] =  HamlFile.new( site, layout_path, relative_path )
+        #site.layouts[ name ] =  HamlFile.new( site, layout_path, relative_path )
+        site.layouts[ name ] =  load_page( layout_path, relative_path )
       end
     end
 
@@ -172,16 +217,7 @@ module Awestruct
         unless ( site.has_page?( path ) )
           file_pathname = Pathname.new( path )
           relative_path = file_pathname.relative_path_from( dir_pathname ).to_s
-          page = nil
-          if ( path =~ /\.haml$/ )
-            page = HamlFile.new( site, path, File.join( '', relative_path ) )
-          elsif ( path =~ /\.md$/ )
-            page = MarukuFile.new( site, path, File.join( '', relative_path ) )
-          elsif ( path =~ /\.sass$/ )
-            page = SassFile.new( site, path, File.join( '', relative_path ) )
-          elsif ( File.file?( path ) )
-            page = VerbatimFile.new( site, path, File.join( '', relative_path ) )
-          end
+          page = load_page( path, relative_path )
           if ( page )
             site.pages << page
           end

data/lib/awestruct/extensions/atomizer.rb

@@ -0,0 +1,21 @@
+module Awestruct
+  module Extensions
+    class Atomizer
+      def initialize(entries_name, output_path)
+        @entries_name = entries_name
+        @output_path = output_path
+      end
+
+      def execute(site)
+        entries = site.send( @entries_name )
+        input_page = File.join( File.dirname(__FILE__), 'template.atom.haml' )
+        page = site.engine.load_page( input_page )
+        page.output_path = @output_path
+        page.entries = entries
+        page.title = site.title || site.base_url
+        site.pages << page
+      end
+
+    end
+  end
+end

data/lib/awestruct/extensions/intense_debate.rb

@@ -0,0 +1,26 @@
+
+#module Awestruct
+  #module Extension
+    #class IntenseDebate
+#
+      #def execute(site)
+      #end
+#
+    #end
+  #end
+#end
+
+module Haml::Helpers
+
+  def intense_debate_comments()
+    html = %Q(<script>\n)
+    html += %Q(  var idcomments_acct='#{site.intense_debate_acct}';\n)
+    html += %Q(  var idcomments_post_id;\n)
+    html += %Q(  var idcomments_post_url;\n)
+    html += %Q(</script>\n)
+    html += %Q(<span id="IDCommentsPostTitle" style="display:none"></span>\n)
+    html += %Q(<script type='text/javascript' src='http://www.intensedebate.com/js/genericCommentWrapperV2.js'></script>\n)
+    html 
+  end
+
+end

data/lib/awestruct/extensions/paginator.rb

@@ -0,0 +1,99 @@
+
+
+module Awestruct
+  module Extensions
+    class Paginator
+
+      module Paginated
+        attr_accessor :window
+        attr_accessor :next_page
+        attr_accessor :previous_page
+        attr_accessor :current_page
+        attr_accessor :current_page_index
+        attr_accessor :pages
+
+        def links
+          html = %Q(<div class="pagination-links">)
+          unless ( previous_page.nil? )
+            html += %Q(<a href="#{previous_page.url}" class="previous-link">Previous</a> )
+          end
+          first_skip = false
+          second_skip = false
+          pages.each_with_index do |page, i|
+            if ( i == current_page_index )
+              html += %Q(<span class="current-page">#{i+1}</span> )
+            elsif ( i <= window )
+              html += %Q(<a href="#{page.url}" class="page-link">#{i+1}</a> )
+            elsif ( ( i > window ) && ( i < ( current_page_index - window ) ) && ! first_skip  )
+              html += %Q(<span class="skip">...</span>)
+              first_skip = true
+            elsif ( ( i > ( current_page_index + window ) ) && ( i < ( ( pages.size - window ) - 1 ) ) && ! second_skip )
+              html += %Q(<span class="skip">...</span>)
+              second_skip = true
+            elsif ( ( i >= ( current_page_index - window ) ) && ( i <= ( current_page_index + window ) ) )
+              html += %Q(<a href="#{page.url}" class="page-link">#{i+1}</a> )
+            elsif ( i >= ( ( pages.size - window ) - 1 ) )
+              html += %Q(<a href="#{page.url}" class="page-link">#{i+1}</a> )
+            end
+          end
+          unless ( next_page.nil? )
+            html += %Q(<a href="#{next_page.url}" class="next-link">Next</a> )
+          end
+          html += %Q(</div>)
+          html
+        end
+
+      end
+
+      def initialize(prop_name, input_path, opts={})
+        @prop_name   = prop_name
+        @input_path  = input_path
+        @per_page    = opts[:per_page] || 20
+        @window_size = opts[:window_size] || 2
+      end
+
+      def execute(site)
+        removal_path = nil
+        all = site.send( @prop_name )
+        i = 1
+        paginated_pages = []
+        all.each_slice( @per_page ) do |slice|
+          page = site.engine.find_and_load_site_page( @input_path )
+          removal_path ||= page.output_path
+          slice.extend( Paginated )
+          page.send( "#{@prop_name}=", slice )
+          if ( i == 1 )
+            page.output_path = File.join( File.dirname( @input_path ), File.basename( @input_path ) + ".html" )
+          else
+            page.output_path = File.join( File.dirname( @input_path ), "page#{i}.html" )
+          end
+          page.paginate_generated = true
+          site.pages << page
+          paginated_pages << page
+          i = i + 1
+        end 
+
+        site.pages.reject!{|page|
+          ( ! page.paginate_generated && ( page.output_path == removal_path ) )
+        }
+
+        prev_page = nil
+        paginated_pages.each_with_index do |page,i|
+          page.posts.current_page       = page
+          page.posts.current_page_index = i
+          page.posts.pages              = paginated_pages
+          page.posts.window             = 1
+
+          if ( prev_page != nil )
+            prev_page.send( @prop_name ).next_page = page
+            page.send( @prop_name ).previous_page  = prev_page
+          end
+
+          prev_page = page
+        end
+
+      end
+    end
+
+  end
+end

data/lib/awestruct/extensions/posts.rb

@@ -3,8 +3,9 @@ module Awestruct
   module Extensions
     class Posts
 
-      def initialize(path_prefix)
+      def initialize(path_prefix, assign_to=:posts)
         @path_prefix = path_prefix
+        @assign_to   = assign_to
       end
 
       def execute(site)
@@ -39,7 +40,7 @@ module Awestruct
           last = e
         end
         
-        site.posts = posts
+        site.send( "#{@assign_to}=", posts )
       end
     end
   end

data/lib/awestruct/extensions/template.atom.haml

@@ -0,0 +1,29 @@
+---
+---
+!!! XML
+
+%feed{ 'xml:base'=>site.base_url, 'xml:lang'=>'en-US', :xmlns=>'http://www.w3.org/2005/Atom' }
+  %id #{site.base_url}
+  %title #{page.title}
+  - unless page.entries.empty?
+    %updated= page.entries.first.date.xmlschema
+    %link{:rel=>"alternate", :type=>"text/html",            :href=>site.base_url}
+    %link{:rel=>"self",      :type=>"application/atom+xml", :href=>"#{site.base_url}#{page.url}" }
+    - for entry in page.entries
+      %entry
+        %id #{site.base_url}#{entry.url}
+        %title= escape_once( entry.title )
+        %updated= entry.date.xmlschema
+        %link{:rel=>"alternate", :type=>"text/html", :href=>"#{site.base_url}#{entry.url}" }
+        %author
+          - if ( defined?( entry.author.name ) )
+            %name= entry.author.name
+            - if ( entry.author.email )
+              %name= entry.author.email
+          - else
+            %name= entry.author
+        %summary
+          = html_to_text( entry.content )
+        %content{:type=>'html'}
+          = escape_once( fully_qualify_urls( site.base_url, entry.content )  )
+  

data/lib/awestruct/marukuable.rb

@@ -16,7 +16,7 @@ module Awestruct
     end
 
     def content
-      context = Awestruct::Engine.create_context( site, page )
+      context = Awestruct::Engine.create_context( site, self )
       render( context )
     end
   end

data/lib/awestruct/renderable_file.rb

@@ -8,11 +8,13 @@ module Awestruct
       super( site )
       self.source_path          = source_path
       self.relative_source_path = relative_source_path
-      dir_name = File.dirname( relative_source_path )
-      if ( dir_name == '.' )
-        self.output_path          = output_filename
-      else
-        self.output_path          = File.join( dir_name, output_filename )
+      unless ( relative_source_path.nil? )
+        dir_name = File.dirname( relative_source_path )
+        if ( dir_name == '.' )
+          self.output_path          = output_filename
+        else
+          self.output_path          = File.join( dir_name, output_filename )
+        end
       end
     end
 

data/lib/awestruct/util/default_inflections.rb

@@ -0,0 +1,45 @@
+      # Proc that is instance evaled to create the default inflections for both the
+      # model inflector and the inflector extension.
+      unless defined?( DEFAULT_INFLECTIONS_PROC )
+        DEFAULT_INFLECTIONS_PROC = proc do
+          plural(/$/, 's')
+          plural(/s$/i, 's')
+          plural(/(alias|(?:stat|octop|vir|b)us)$/i, '\1es')
+          plural(/(buffal|tomat)o$/i, '\1oes')
+          plural(/([ti])um$/i, '\1a')
+          plural(/sis$/i, 'ses')
+          plural(/(?:([^f])fe|([lr])f)$/i, '\1\2ves')
+          plural(/(hive)$/i, '\1s')
+          plural(/([^aeiouy]|qu)y$/i, '\1ies')
+          plural(/(x|ch|ss|sh)$/i, '\1es')
+          plural(/(matr|vert|ind)ix|ex$/i, '\1ices')
+          plural(/([m|l])ouse$/i, '\1ice')
+      
+          singular(/s$/i, '')
+          singular(/([ti])a$/i, '\1um')
+          singular(/(analy|ba|cri|diagno|parenthe|progno|synop|the)ses$/i, '\1sis')
+          singular(/([^f])ves$/i, '\1fe')
+          singular(/([h|t]ive)s$/i, '\1')
+          singular(/([lr])ves$/i, '\1f')
+          singular(/([^aeiouy]|qu)ies$/i, '\1y')
+          singular(/(m)ovies$/i, '\1ovie')
+          singular(/(x|ch|ss|sh)es$/i, '\1')
+          singular(/([m|l])ice$/i, '\1ouse')
+          singular(/buses$/i, 'bus')
+          singular(/oes$/i, 'o')
+          singular(/shoes$/i, 'shoe')
+          singular(/(alias|(?:stat|octop|vir|b)us)es$/i, '\1')
+          singular(/(vert|ind)ices$/i, '\1ex')
+          singular(/matrices$/i, 'matrix')
+      
+          irregular('person', 'people')
+          irregular('man', 'men')
+          irregular('child', 'children')
+          irregular('sex', 'sexes')
+          irregular('move', 'moves')
+          irregular('quiz', 'quizzes')
+          irregular('testis', 'testes')
+      
+          uncountable(%w(equipment information rice money species series fish sheep news))
+        end
+      end

data/lib/awestruct/util/inflector.rb

@@ -0,0 +1,242 @@
+# The inflector extension adds inflection instance methods to String, which allows the easy transformation of
+# words from singular to plural, class names to table names, modularized class
+# names to ones without, and class names to foreign keys.  It exists for 
+# backwards compatibility to legacy Sequel code.
+
+class String
+  # This module acts as a singleton returned/yielded by String.inflections,
+  # which is used to override or specify additional inflection rules. Examples:
+  #
+  #   String.inflections do |inflect|
+  #     inflect.plural /^(ox)$/i, '\1\2en'
+  #     inflect.singular /^(ox)en/i, '\1'
+  #
+  #     inflect.irregular 'octopus', 'octopi'
+  #
+  #     inflect.uncountable "equipment"
+  #   end
+  #
+  # New rules are added at the top. So in the example above, the irregular rule for octopus will now be the first of the
+  # pluralization and singularization rules that is runs. This guarantees that your rules run before any of the rules that may
+  # already have been loaded.
+  module Inflections
+    @plurals, @singulars, @uncountables = [], [], []
+
+    class << self
+      # Array of 2 element arrays, first containing a regex, and the second containing a substitution pattern, used for plurization.
+      attr_reader :plurals
+
+      # Array of 2 element arrays, first containing a regex, and the second containing a substitution pattern, used for singularization.
+      attr_reader :singulars
+
+      # Array of strings for words were the singular form is the same as the plural form
+      attr_reader :uncountables
+    end
+
+    # Clears the loaded inflections within a given scope (default is :all). Give the scope as a symbol of the inflection type,
+    # the options are: :plurals, :singulars, :uncountables
+    #
+    # Examples:
+    #   clear :all
+    #   clear :plurals
+    def self.clear(scope = :all)
+      case scope
+      when :all
+        @plurals, @singulars, @uncountables = [], [], []
+      else
+        instance_variable_set("@#{scope}", [])
+      end
+    end
+
+    # Specifies a new irregular that applies to both pluralization and singularization at the same time. This can only be used
+    # for strings, not regular expressions. You simply pass the irregular in singular and plural form.
+    #
+    # Examples:
+    #   irregular 'octopus', 'octopi'
+    #   irregular 'person', 'people'
+    def self.irregular(singular, plural)
+      plural(Regexp.new("(#{singular[0,1]})#{singular[1..-1]}$", "i"), '\1' + plural[1..-1])
+      singular(Regexp.new("(#{plural[0,1]})#{plural[1..-1]}$", "i"), '\1' + singular[1..-1])
+    end
+
+    # Specifies a new pluralization rule and its replacement. The rule can either be a string or a regular expression.
+    # The replacement should always be a string that may include references to the matched data from the rule.
+    #
+    # Example:
+    #   plural(/(x|ch|ss|sh)$/i, '\1es')
+    def self.plural(rule, replacement)
+      @plurals.insert(0, [rule, replacement])
+    end
+
+    # Specifies a new singularization rule and its replacement. The rule can either be a string or a regular expression.
+    # The replacement should always be a string that may include references to the matched data from the rule.
+    #
+    # Example:
+    #   singular(/([^aeiouy]|qu)ies$/i, '\1y') 
+    def self.singular(rule, replacement)
+      @singulars.insert(0, [rule, replacement])
+    end
+
+    # Add uncountable words that shouldn't be attempted inflected.
+    #
+    # Examples:
+    #   uncountable "money"
+    #   uncountable "money", "information"
+    #   uncountable %w( money information rice )
+    def self.uncountable(*words)
+      (@uncountables << words).flatten!
+    end
+
+    load( File.join( File.dirname(__FILE__), 'default_inflections.rb' ) )
+    instance_eval(&DEFAULT_INFLECTIONS_PROC)
+  end
+
+  # Yield the Inflections module if a block is given, and return
+  # the Inflections module.
+  def self.inflections
+    yield Inflections if block_given?
+    Inflections
+  end
+
+  # By default, camelize converts the string to UpperCamelCase. If the argument to camelize
+  # is set to :lower then camelize produces lowerCamelCase.
+  #
+  # camelize will also convert '/' to '::' which is useful for converting paths to namespaces
+  #
+  # Examples
+  #   "active_record".camelize #=> "ActiveRecord"
+  #   "active_record".camelize(:lower) #=> "activeRecord"
+  #   "active_record/errors".camelize #=> "ActiveRecord::Errors"
+  #   "active_record/errors".camelize(:lower) #=> "activeRecord::Errors"
+  def camelize(first_letter_in_uppercase = :upper)
+    s = gsub(/\/(.?)/){|x| "::#{x[-1..-1].upcase unless x == '/'}"}.gsub(/(^|_)(.)/){|x| x[-1..-1].upcase}
+    s[0...1] = s[0...1].downcase unless first_letter_in_uppercase == :upper
+    s
+  end
+  alias_method :camelcase, :camelize
+
+  # Singularizes and camelizes the string.  Also strips out all characters preceding
+  # and including a period (".").
+  #
+  # Examples
+  #   "egg_and_hams".classify #=> "EggAndHam"
+  #   "post".classify #=> "Post"
+  #   "schema.post".classify #=> "Post"
+  def classify
+    sub(/.*\./, '').singularize.camelize
+  end
+
+  # Constantize tries to find a declared constant with the name specified
+  # in the string. It raises a NameError when the name is not in CamelCase
+  # or is not initialized.
+  #
+  # Examples
+  #   "Module".constantize #=> Module
+  #   "Class".constantize #=> Class
+  def constantize
+    raise(NameError, "#{inspect} is not a valid constant name!") unless m = /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/.match(self)
+    Object.module_eval("::#{m[1]}", __FILE__, __LINE__)
+  end
+
+  # Replaces underscores with dashes in the string.
+  #
+  # Example
+  #   "puni_puni".dasherize #=> "puni-puni"
+  def dasherize
+    gsub(/_/, '-')
+  end
+
+  # Removes the module part from the expression in the string
+  #
+  # Examples
+  #   "ActiveRecord::CoreExtensions::String::Inflections".demodulize #=> "Inflections"
+  #   "Inflections".demodulize #=> "Inflections"
+  def demodulize
+    gsub(/^.*::/, '')
+  end
+
+  # Creates a foreign key name from a class name.
+  # +use_underscore+ sets whether the method should put '_' between the name and 'id'.
+  #
+  # Examples
+  #   "Message".foreign_key #=> "message_id"
+  #   "Message".foreign_key(false) #=> "messageid"
+  #   "Admin::Post".foreign_key #=> "post_id"
+  def foreign_key(use_underscore = true)
+    "#{demodulize.underscore}#{'_' if use_underscore}id"
+  end
+
+  # Capitalizes the first word and turns underscores into spaces and strips _id.
+  # Like titleize, this is meant for creating pretty output.
+  #
+  # Examples
+  #   "employee_salary" #=> "Employee salary"
+  #   "author_id" #=> "Author"
+  def humanize
+    gsub(/_id$/, "").gsub(/_/, " ").capitalize
+  end
+
+  # Returns the plural form of the word in the string.
+  #
+  # Examples
+  #   "post".pluralize #=> "posts"
+  #   "octopus".pluralize #=> "octopi"
+  #   "sheep".pluralize #=> "sheep"
+  #   "words".pluralize #=> "words"
+  #   "the blue mailman".pluralize #=> "the blue mailmen"
+  #   "CamelOctopus".pluralize #=> "CamelOctopi"
+  def pluralize
+    result = dup
+    Inflections.plurals.each{|(rule, replacement)| break if result.gsub!(rule, replacement)} unless Inflections.uncountables.include?(downcase)
+    result
+  end
+
+  # The reverse of pluralize, returns the singular form of a word in a string.
+  #
+  # Examples
+  #   "posts".singularize #=> "post"
+  #   "octopi".singularize #=> "octopus"
+  #   "sheep".singluarize #=> "sheep"
+  #   "word".singluarize #=> "word"
+  #   "the blue mailmen".singularize #=> "the blue mailman"
+  #   "CamelOctopi".singularize #=> "CamelOctopus"
+  def singularize
+    result = dup
+    Inflections.singulars.each{|(rule, replacement)| break if result.gsub!(rule, replacement)} unless Inflections.uncountables.include?(downcase)
+    result
+  end
+
+  # Underscores and pluralizes the string.
+  #
+  # Examples
+  #   "RawScaledScorer".tableize #=> "raw_scaled_scorers"
+  #   "egg_and_ham".tableize #=> "egg_and_hams"
+  #   "fancyCategory".tableize #=> "fancy_categories"
+  def tableize
+    underscore.pluralize
+  end
+
+  # Capitalizes all the words and replaces some characters in the string to create
+  # a nicer looking title. Titleize is meant for creating pretty output.
+  #
+  # titleize is also aliased as as titlecase
+  #
+  # Examples
+  #   "man from the boondocks".titleize #=> "Man From The Boondocks"
+  #   "x-men: the last stand".titleize #=> "X Men: The Last Stand"
+  def titleize
+    underscore.humanize.gsub(/\b([a-z])/){|x| x[-1..-1].upcase}
+  end
+  alias_method :titlecase, :titleize
+
+  # The reverse of camelize. Makes an underscored form from the expression in the string.
+  # Also changes '::' to '/' to convert namespaces to paths.
+  #
+  # Examples
+  #   "ActiveRecord".underscore #=> "active_record"
+  #   "ActiveRecord::Errors".underscore #=> active_record/errors
+  def underscore
+    gsub(/::/, '/').gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+      gsub(/([a-z\d])([A-Z])/,'\1_\2').tr("-", "_").downcase
+  end
+end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 3
-  version: 0.0.3
+  - 4
+  version: 0.0.4
 platform: ruby
 authors: 
 - Bob McWhirter
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-02-26 00:00:00 -05:00
+date: 2010-02-28 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -93,7 +93,10 @@ files:
 - lib/awestruct/commands/server.rb
 - lib/awestruct/config.rb
 - lib/awestruct/engine.rb
+- lib/awestruct/extensions/atomizer.rb
 - lib/awestruct/extensions/indexifier.rb
+- lib/awestruct/extensions/intense_debate.rb
+- lib/awestruct/extensions/paginator.rb
 - lib/awestruct/extensions/pipeline.rb
 - lib/awestruct/extensions/posts.rb
 - lib/awestruct/front_matter_file.rb
@@ -107,10 +110,13 @@ files:
 - lib/awestruct/sass_file.rb
 - lib/awestruct/sassable.rb
 - lib/awestruct/site.rb
+- lib/awestruct/util/default_inflections.rb
+- lib/awestruct/util/inflector.rb
 - lib/awestruct/verbatim_file.rb
 - lib/awestruct.rb
 - lib/awestruct/commands/base_index.html.haml
 - lib/awestruct/commands/base_layout.html.haml
+- lib/awestruct/extensions/template.atom.haml
 has_rdoc: true
 homepage: 
 licenses: []