psychgus 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d8fc77e8bff6b4c3b09e3b4b895c3f5b8e5b10d008a1fd3fd96b94061e96b403
+  data.tar.gz: a9f79466520817c04a017f06d27fad23b3a0a2043aa21d6efb377cab1b3d9bcf
+SHA512:
+  metadata.gz: 43ed14aaab0bac8b8f9e168ec9e085925ec17942ddbcc3356e9782c70bbc2cd4dd3ccf2c7c6f70fab5fbe424c02a710a16cb7956a059f0f0e3a6f83226eb270d
+  data.tar.gz: e1716f1e701afdb87d8086d5c2553b04356478ef6356586b7db25180f19fa4b0c5c38d32800be2d2794f4e72cf58205e6c63a1326c9d4a3a6c864b207f3b48ec

data/Gemfile

@@ -0,0 +1,25 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+#--
+# This file is part of Psychgus.
+# Copyright (c) 2017-2019 Jonathan Bradley Whited (@esotericpig)
+# 
+# Psychgus is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# Psychgus is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+# 
+# You should have received a copy of the GNU Lesser General Public License
+# along with Psychgus.  If not, see <http://www.gnu.org/licenses/>.
+#++
+
+
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,165 @@
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

data/README.md

@@ -0,0 +1,507 @@
+# Psychgus
+
+Psychgus uses the core standard library [Psych](https://github.com/ruby/psych) for working with [YAML](https://yaml.org) and extends it so that developers can easily style the YAML according to their needs.
+
+Thank you to the people that worked and continue to work hard on the Psych project.
+
+The Psychgus name comes from the well-styled character Gus from the TV show Psych.
+
+## Contents
+
+- [Setup](#setup)
+- [Using](#using)
+    - [Simple Example](#simple-example)
+    - [Hash Example](#hash-example)
+    - [Class Example](#class-example)
+    - [Advanced Usage](#advanced-usage)
+- [Hacking](#hacking)
+    - [Testing](#testing)
+    - [Generating Doc](#generating-doc)
+- [License](#license)
+
+## [Setup](#contents)
+
+Pick your poison...
+
+- With the RubyGems CLI package manager:
+    - `$ gem install psychgus`
+- In your *Gemspec* (*<project>.gemspec*):
+    - `spec.add_runtime_dependency 'psychgus','~> x.x.x'`
+    - Or, if you only need Psychgus in development (e.g., tests, rake, documentation):
+        - `spec.add_development_dependency 'psychgus','~> x.x.x'`
+- In your *Gemfile*:
+    - `gem 'psychgus','~> x.x.x'`
+    - Or, with GitHub:
+        - `gem 'psychgus',:git=>'https://github.com/esotericpig/psychgus.git'`
+- Manually:
+    - `$ git clone 'https://github.com/esotericpig/psychgus.git'`
+    - `$ cd psychgus`
+    - `$ bundle install`
+    - `$ bundle exec rake install:local`
+
+## [Using](#contents)
+
+Documentation (YARDoc) is available on my [GitHub Page](https://esotericpig.github.io/docs/psychgus/yardoc/index.html) and RubyDoc.info ([[/gems]](https://www.rubydoc.info/gems/psychgus) or [[/github]](https://www.rubydoc.info/github/esotericpig/psychgus/master)).
+
+To begin styling, create a class and mix in (include) `Psychgus::Styler`. Then pass it in as a keyword arg (`stylers: MyStyler.new` or `stylers: [MyStyler1.new,MyStyler2.new]`) into one of the Psychgus methods.
+
+For classes, you can optionally include `Psychgus::Blueberry` and return the styler(s) for the class by defining the `psychgus_stylers(sniffer)` method.
+
+### [Simple Example](#contents)
+
+```Ruby
+require 'psychgus'
+
+class CoffeeStyler
+  include Psychgus::Styler
+  
+  def style_sequence(sniffer,node)
+    node.style = Psychgus::SEQUENCE_FLOW
+  end
+end
+
+coffee = {
+  'Roast'=>['Light', 'Medium', 'Dark', 'Extra Dark'],
+  'Style'=>['Cappuccino', 'Espresso', 'Latte', 'Mocha']
+}
+
+puts coffee.to_yaml(stylers: CoffeeStyler.new)
+
+# Output:
+# ---
+# Roast: [Light, Medium, Dark, Extra Dark]
+# Style: [Cappuccino, Espresso, Latte, Mocha]
+
+class Coffee
+  include Psychgus::Blueberry
+  
+  def initialize
+    @roast = ['Light', 'Medium', 'Dark', 'Extra Dark']
+    @style = ['Cappuccino', 'Espresso', 'Latte', 'Mocha']
+  end
+  
+  def psychgus_stylers(sniffer)
+    CoffeeStyler.new
+  end
+end
+
+puts Coffee.new.to_yaml
+
+# Output:
+# --- !ruby/object:Coffee
+# roast: [Light, Medium, Dark, Extra Dark]
+# style: [Cappuccino, Espresso, Latte, Mocha]
+```
+
+### [Hash Example](#contents)
+
+```Ruby
+require 'psychgus'
+
+class BurgerStyler
+  include Psychgus::Styler # Mix in methods needed for styling
+  
+  # Style maps (Psych::Nodes::Mapping)
+  # - Hashes (key/value pairs)
+  # - Example: "Burgers: Classic {}"
+  def style_mapping(sniffer,node)
+    node.style = Psychgus::MAPPING_FLOW if sniffer.level >= 4
+  end
+  
+  # Style scalars (Psych::Nodes::Scalar)
+  # - Any text (non-alias)
+  def style_scalar(sniffer,node)
+    # Remove colon (change symbols into strings)
+    node.value = node.value.sub(':','')
+    
+    # Capitalize each word
+    node.value = node.value.split(' ').map do |v|
+      if v.casecmp('BBQ') == 0
+        v.upcase()
+      else
+        v.capitalize()
+      end
+    end.join(' ')
+    
+    # Change lettuce to spinach
+    node.value = 'Spinach' if node.value == 'Lettuce'
+  end
+  
+  # Style sequences (Psych::Nodes::Sequence)
+  # - Arrays
+  # - Example: "[Lettuce, Onions, Pickles, Tomatoes]"
+  def style_sequence(sniffer,node)
+    node.style = Psychgus::SEQUENCE_FLOW if sniffer.level >= 4
+  end
+end
+
+burgers = {
+  :burgers => {
+    :classic => {:sauce  => %w(Ketchup Mustard),
+                 :cheese => 'American',
+                 :bun    => 'Sesame Seed'},
+    :bbq     => {:sauce  => 'Honey BBQ',
+                 :cheese => 'Cheddar',
+                 :bun    => 'Kaiser'},
+    :fancy   => {:sauce  => 'Spicy Wasabi',
+                 :cheese => 'Smoked Gouda',
+                 :bun    => 'Hawaiian'}
+  },
+  :toppings => [
+    'Mushrooms',
+    %w(Lettuce Onions Pickles Tomatoes),
+    [%w(Ketchup Mustard), %w(Salt Pepper)]
+  ]
+}
+burgers[:favorite] = burgers[:burgers][:bbq] # Alias
+
+puts burgers.to_yaml(indent: 3,stylers: BurgerStyler.new)
+
+# Output:
+# ---
+# Burgers:
+#    Classic: {Sauce: [Ketchup, Mustard], Cheese: American, Bun: Sesame Seed}
+#    BBQ: &1 {Sauce: Honey BBQ, Cheese: Cheddar, Bun: Kaiser}
+#    Fancy: {Sauce: Spicy Wasabi, Cheese: Smoked Gouda, Bun: Hawaiian}
+# Toppings:
+# - Mushrooms
+# - [Spinach, Onions, Pickles, Tomatoes]
+# - [[Ketchup, Mustard], [Salt, Pepper]]
+# Favorite: *1
+
+# Or pass in a Hash. Can also dereference aliases.
+puts burgers.to_yaml({:indent => 3,:stylers => BurgerStyler.new,:deref_aliases => true})
+
+# Output:
+# ---
+# Burgers:
+#    Classic: {Sauce: [Ketchup, Mustard], Cheese: American, Bun: Sesame Seed}
+#    BBQ: {Sauce: Honey BBQ, Cheese: Cheddar, Bun: Kaiser}
+#    Fancy: {Sauce: Spicy Wasabi, Cheese: Smoked Gouda, Bun: Hawaiian}
+# Toppings:
+# - Mushrooms
+# - [Spinach, Onions, Pickles, Tomatoes]
+# - [[Ketchup, Mustard], [Salt, Pepper]]
+# Favorite:
+#    Sauce: Honey BBQ
+#    Cheese: Cheddar
+#    Bun: Kaiser
+```
+
+### [Class Example](#contents)
+
+```Ruby
+require 'psychgus'
+
+class BurgerStyler
+  include Psychgus::Styler # Mix in methods needed for styling
+  
+  def initialize(sniffer)
+    @class_level    = sniffer.level
+    @class_position = sniffer.position
+  end
+  
+  # Style all nodes (Psych::Nodes::Node)
+  def style(sniffer,node)
+    # Remove "!ruby/object:..." for Burger classes (not Burgers class)
+    node.tag = nil if node.node_of?(:mapping,:scalar,:sequence)
+    
+    # This is another way to do the above
+    #node.tag = nil if node.respond_to?(:tag=)
+  end
+  
+  # Style maps (Psych::Nodes::Mapping)
+  # - Hashes (key/value pairs)
+  # - Example: "Burgers: Classic {}"
+  def style_mapping(sniffer,node)
+    parent = sniffer.parent
+    
+    if !parent.nil?()
+      # BBQ
+      node.style = Psychgus::MAPPING_FLOW if parent.node_of?(:scalar) &&
+                                             parent.value.casecmp('BBQ') == 0
+    end
+  end
+  
+  # Style scalars (Psych::Nodes::Scalar)
+  # - Any text (non-alias)
+  def style_scalar(sniffer,node)
+    parent = sniffer.parent
+    
+    # Single quote scalars that are not keys to a map
+    node.style = Psychgus::SCALAR_SINGLE_QUOTED if !parent.nil?() &&
+                                                   parent.child_type != :key
+  end
+  
+  # Style sequences (Psych::Nodes::Sequence)
+  # - Arrays
+  # - Example: "[Lettuce, Onions, Pickles, Tomatoes]"
+  def style_sequence(sniffer,node)
+    relative_level = (sniffer.level - @class_level) + 1
+    
+    # "[Ketchup, Mustard]"
+    node.style = Psychgus::SEQUENCE_FLOW if relative_level == 3
+  end
+end
+
+class Burger
+  include Psychgus::Blueberry # Mix in methods needed to be stylable
+  
+  attr_accessor :bun
+  attr_accessor :cheese
+  attr_accessor :sauce
+  
+  def initialize(sauce,cheese,bun)
+    @bun    = bun
+    @cheese = cheese
+    @sauce  = sauce
+  end
+  
+  # Return our styler(s)
+  # - Can be an Array: [MyStyler1.new, MyStyler2.new]
+  def psychgus_stylers(sniffer)
+    return BurgerStyler.new(sniffer)
+  end
+  
+  # You can still use Psych's encode_with(), no problem
+  def encode_with(coder)
+    coder['Bun']    = @bun
+    coder['Cheese'] = @cheese
+    coder['Sauce']  = @sauce
+  end
+end
+
+class Burgers
+  attr_accessor :burgers
+  attr_accessor :toppings
+  attr_accessor :favorite
+  
+  def initialize()
+    @burgers = {
+      'Classic' => Burger.new(['Ketchup','Mustard'],'American'    ,'Sesame Seed'),
+      'BBQ'     => Burger.new('Honey BBQ'          ,'Cheddar'     ,'Kaiser'),
+      'Fancy'   => Burger.new('Spicy Wasabi'       ,'Smoked Gouda','Hawaiian')
+    }
+    
+    @toppings = [
+      'Mushrooms',
+      %w(Lettuce Onions Pickles Tomatoes),
+      [%w(Ketchup Mustard),%w(Salt Pepper)]
+    ]
+    
+    @favorite = @burgers['BBQ'] # Alias
+  end
+  
+  # You can still use Psych's encode_with(), no problem
+  def encode_with(coder)
+    coder['Burgers']  = @burgers
+    coder['Toppings'] = @toppings
+    coder['Favorite'] = @favorite
+  end
+end
+
+burgers = Burgers.new
+
+puts burgers.to_yaml(indent: 3)
+
+# Output:
+# --- !ruby/object:Burgers
+# Burgers:
+#    Classic:
+#       Bun: 'Sesame Seed'
+#       Cheese: 'American'
+#       Sauce: ['Ketchup', 'Mustard']
+#    BBQ: &1 {Bun: 'Kaiser', Cheese: 'Cheddar', Sauce: 'Honey BBQ'}
+#    Fancy:
+#       Bun: 'Hawaiian'
+#       Cheese: 'Smoked Gouda'
+#       Sauce: 'Spicy Wasabi'
+# Toppings:
+# - Mushrooms
+# -  - Lettuce
+#    - Onions
+#    - Pickles
+#    - Tomatoes
+# -  -  - Ketchup
+#       - Mustard
+#    -  - Salt
+#       - Pepper
+# Favorite: *1
+
+# Or pass in a Hash. Can also dereference aliases.
+puts burgers.to_yaml({:indent => 3,:deref_aliases => true})
+
+# Output:
+# --- !ruby/object:Burgers
+# Burgers:
+#    Classic:
+#       Bun: 'Sesame Seed'
+#       Cheese: 'American'
+#       Sauce: ['Ketchup', 'Mustard']
+#    BBQ: {Bun: 'Kaiser', Cheese: 'Cheddar', Sauce: 'Honey BBQ'}
+#    Fancy:
+#       Bun: 'Hawaiian'
+#       Cheese: 'Smoked Gouda'
+#       Sauce: 'Spicy Wasabi'
+# Toppings:
+# - Mushrooms
+# -  - Lettuce
+#    - Onions
+#    - Pickles
+#    - Tomatoes
+# -  -  - Ketchup
+#       - Mustard
+#    -  - Salt
+#       - Pepper
+# Favorite:
+#    Bun: 'Kaiser'
+#    Cheese: 'Cheddar'
+#    Sauce: 'Honey BBQ'
+```
+
+### [Advanced Usage](#contents)
+
+```Ruby
+require 'psychgus'
+
+class MyStyler
+  include Psychgus::Styler
+  
+  def style_sequence(sniffer,node)
+    node.style = Psychgus::SEQUENCE_FLOW
+  end
+end
+
+coffee = {
+  'Coffee' => {
+    'Roast'=>['Light', 'Medium', 'Dark', 'Extra Dark'],
+    'Style'=>['Cappuccino', 'Espresso', 'Latte', 'Mocha']
+  }
+}
+eggs = {
+  'Eggs' => {
+    'Color'=>['Brown', 'White', 'Blue', 'Olive'],
+    'Style'=>['Fried', 'Scrambled', 'Omelette', 'Poached']
+  }
+}
+
+filename = 'coffee-and-eggs.yaml'
+styler = MyStyler.new
+options = {:indentation=>3, :stylers=>styler, :deref_aliases=>true}
+
+coffee_yaml = coffee.to_yaml(options)
+coffee_and_eggs_yaml = Psychgus.dump_stream(coffee,eggs,options)
+
+
+# High-level emitting
+puts Psychgus.dump(coffee,options)
+puts
+
+Psychgus.dump_file(filename,coffee,eggs,options)
+puts File.readlines(filename)
+puts
+
+puts Psychgus.dump_stream(coffee,eggs,options)
+puts
+
+puts coffee.to_yaml(options)
+puts
+
+# High-level parsing
+# - Because to_ruby() will be called, just use Psych:
+#   - load(), load_file(), load_stream(), safe_load()
+
+# Mid-level emitting
+stream = Psychgus.parse_stream(coffee_and_eggs_yaml,options)
+
+puts stream.to_yaml()
+puts
+
+# Mid-level parsing
+puts Psychgus.parse(coffee_yaml,options).to_ruby
+puts
+
+puts Psychgus.parse_file(filename,options).to_ruby
+puts
+
+i = 0
+Psychgus.parse_stream(coffee_and_eggs_yaml,options) do |doc|
+  puts "Doc ##{i += 1}:"
+  puts "  #{doc.to_ruby}"
+end
+puts
+
+# Low-level emitting
+tree_builder = Psychgus::StyledTreeBuilder.new(styler,options)
+visitor = Psych::Visitors::YAMLTree.create(options,tree_builder)
+
+visitor << coffee
+visitor << eggs
+
+puts visitor.tree.to_yaml
+puts
+
+# Low-level parsing
+parser = Psychgus.parser(options)
+
+parser.parse(coffee_yaml)
+
+puts parser.handler.root.to_ruby
+puts
+```
+
+## [Hacking](#contents)
+
+```
+$ git clone 'https://github.com/esotericpig/psychgus.git'
+$ bundle install
+$ bundle exec rake -T
+```
+
+### [Testing](#contents)
+
+Run tests, excluding tests that create temp files:
+
+`$ bundle exec rake test`
+
+Run all tests:
+
+`$ bundle exec rake test_all`
+
+### [Generating Doc](#contents)
+
+Generate basic doc:
+
+`$ bundle exec rake yard`
+
+Fix GitHub-specific differences:
+
+`$ bundle exec rake yard_fix`
+
+Clean doc &amp; run all of the above:
+
+`$ bundle exec rake yard_fresh`
+
+Deploy doc to my GitHub Page (not useful for others):
+
+`$ bundle exec rake ghp_doc`
+
+## [License](#contents)
+
+[GNU LGPL v3+](LICENSE.txt)
+
+> Psychgus (<https://github.com/esotericpig/psychgus>)  
+> Copyright (c) 2017-2019 Jonathan Bradley Whited (@esotericpig)  
+> 
+> Psychgus is free software: you can redistribute it and/or modify  
+> it under the terms of the GNU Lesser General Public License as published by  
+> the Free Software Foundation, either version 3 of the License, or  
+> (at your option) any later version.  
+> 
+> Psychgus is distributed in the hope that it will be useful,  
+> but WITHOUT ANY WARRANTY; without even the implied warranty of  
+> MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the  
+> GNU Lesser General Public License for more details.  
+> 
+> You should have received a copy of the GNU Lesser General Public License  
+> along with Psychgus.  If not, see <http://www.gnu.org/licenses/>.