conversion 0.1.0

data/lib/conversion/mode/human_input/core.rb

@@ -0,0 +1,74 @@
+module Conversion  
+  class << self
+    # You're not supposed to call this method. Use Conversion.converter or Conversion.entries_converter instead.
+    #
+    # This method implements the :human_input conversion mode.
+    def human_input_converter(target)
+      base_converter = converter(target, :mode=>:weak)
+
+      return base_converter unless
+        base_converter &&
+        target.is_a?(Class)
+
+      proc do |value|
+        value = value.convert_to(Conversion::HumanInputString)
+        if value.nil? || value.empty?
+          nil
+        else
+          value = value.gsub(',','.').gsub(/ /,'') if value =~ /^[-+]?[ \d]*[\.,]?\d+$/
+          base_converter.call(value)
+        end
+      end
+    end
+  end
+  
+  # This module provides conversion to clean, stripped, strings.
+  #
+  #   <object>.convert_to(Conversion::HumanInputString)
+  #
+  # See Conversion::HumanInputString.to_converter_proc
+  module HumanInputString
+    class << self
+      # Returns a Proc that converts to a clean, stripped, string.
+      #
+      #   Conversion::HumanInputString.to_converter_proc.call("\n1   2\n3 ")
+      #   # => "1 2\n3"
+      #
+      # Blank objects are converted to nil:
+      #
+      #   Conversion::HumanInputString.to_converter_proc.call("\n ")
+      #   # => nil
+      #
+      # If the converted object has a :to_human_input_string method, it is used before cleaning, stripping and blank-checking. (See Date#to_human_input_string)
+      #
+      #   class Date
+      #     def to_human_input_string() ... end
+      #   end
+      #   Conversion::HumanInputString.to_converter_proc.call(Date.now)
+      #   # => "10/22/2006"
+      #
+      # See Conversion.converter, Object#convert_to
+      #
+      # NB: if your object has a :to_human_input_string, <b>make yourself sure</b> that:
+      #   object.convert_to(Conversion::HumanInputString).convert_to(object.class, :mode=>:human_input) == object
+      
+      def to_converter_proc
+        proc do |value|
+          begin
+            value = value.to_human_input_string
+          rescue NoMethodError
+            value = value.to_s
+          end
+          # compact spaces and non-breaking-spaces runs
+          value = value.gsub(/[  ]+/,' ').strip unless value.nil?
+          if value.nil? || value.empty?
+            nil
+          else
+            value
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/conversion/mode/human_input.rb

@@ -0,0 +1,2 @@
+require 'conversion/mode/human_input/core'
+require 'conversion/mode/human_input/class_decoration'

data/lib/conversion/mode/nil_on_failure.rb

@@ -0,0 +1,33 @@
+module Conversion
+  class << self
+    # You're not supposed to call this method. Use Conversion.converter or Conversion.entries_converter instead.
+    #
+    # This method implements the :nil_on_failure conversion mode.
+    def nil_on_failure_converter(target)
+      base_converter = converter(target)
+
+      return nil unless base_converter
+      
+      if target.is_a?(Class)
+        proc do |value|
+          begin
+            result = base_converter.call(value)
+            result = nil unless result.is_a?(target)
+          rescue Exception
+            result = nil
+          end
+          result
+        end
+      else
+        proc do |value|
+          begin
+            base_converter.call(value)
+          rescue Exception
+            nil
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/conversion/mode/stable_nil.rb

@@ -0,0 +1,19 @@
+module Conversion
+  class << self
+    # You're not supposed to call this method. Use Conversion.converter or Conversion.entries_converter instead.
+    #
+    # This method implements the :stable_nil conversion mode.
+    def stable_nil_converter(target)
+      base_converter = converter(target)
+      return nil unless base_converter
+      proc do |value|
+        if value.nil?
+          nil
+        else
+          base_converter.call(value)
+        end
+      end
+    end
+  end
+end
+

data/lib/conversion/mode/strong_type_checking.rb

@@ -0,0 +1,24 @@
+module Conversion
+  class << self
+    # You're not supposed to call this method. Use Conversion.converter or Conversion.entries_converter instead.
+    #
+    # This method implements the :strong_type_checking conversion mode.
+    def strong_type_checking_converter(target)
+      base_converter = converter(target)
+
+      return base_converter unless
+        base_converter &&
+        target.is_a?(Class)
+
+      proc do |value|
+        if value.nil?
+          nil
+        else
+  		    raise ArgumentError.new("Invalid value for #{target}: #{value.inspect}") unless value.is_a?(target)
+          value
+  	    end
+      end
+    end
+  end
+end
+

data/lib/conversion/mode/weak.rb

@@ -0,0 +1,33 @@
+module Conversion
+  class << self
+    # You're not supposed to call this method. Use Conversion.converter or Conversion.entries_converter instead.
+    #
+    # This method implements the :weak conversion mode.
+    def weak_converter(target)
+      base_converter = converter(target)
+
+      return nil unless base_converter
+      
+      if target.is_a?(Class)
+        proc do |value|
+          begin
+            result = base_converter.call(value)
+            result = value unless result.is_a?(target)
+          rescue Exception
+            result = value
+          end
+          result
+        end
+      else
+        proc do |value|
+          begin
+            base_converter.call(value)
+          rescue Exception
+            value
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/conversion/object_decoration.rb

@@ -0,0 +1,23 @@
+class Object
+  # Converts self to target, with options
+  #
+  #   '1'.convert_to(Integer)
+  #   # => 1
+  #
+  # See Conversion.converter for options description
+  def convert_to(target, options={})
+    Conversion.converter(target, options).call(self)
+  end
+  
+  # Converts self to target, with options and enumarable support
+  #
+  #   ['1', ['2']].convert_entries_to(Integer)
+  #   # => [1, [2]]
+  #   '1'.convert_entries_to(Integer)
+  #   # => 1
+  #
+  # See Conversion.entries_converter for options description
+  def convert_entries_to(target, options={})
+    Conversion.entries_converter(target, options).call(self)
+  end
+end

data/lib/conversion/version.rb

@@ -0,0 +1,9 @@
+module Conversion #:nodoc:
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 1
+    TINY  = 0
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

data/lib/conversion.rb

@@ -0,0 +1,22 @@
+$:.unshift(File.dirname(__FILE__))
+
+# Conversion.converter(<target>)
+require "conversion/core"
+
+# <Object>.convert_to(<target>)
+require "conversion/object_decoration"
+
+# class A; include Conversion::Accessors; attr_accessor <attr>, :store_as => <target>; end
+require "conversion/accessors"
+
+# Symbol, Strings, Integer, Float, etc.
+require "conversion/class_decoration"
+
+# conversion modes
+require "conversion/mode/weak"
+require "conversion/mode/strong_type_checking"
+require "conversion/mode/stable_nil"
+require "conversion/mode/nil_on_failure"
+require "conversion/mode/human_input"
+
+$:.shift

data/lib/conversion_test.rb

@@ -0,0 +1,336 @@
+require 'conversion'
+require 'date'
+
+$assertions = 0
+def assert(condition)
+  raise "Assertion failed" unless condition
+  $assertions += 1
+end
+
+def assert_exception(klass=Exception)
+  begin
+    yield
+  rescue klass
+    $assertions += 1
+  rescue Exception
+    raise
+  else
+    raise "Assertion failed"
+  end
+end
+
+# -----------------
+
+class Money
+  include Conversion::Accessors
+  attr_accessor :amount, :store_as => Float
+  attr_accessor :currency, :store_as => Symbol
+  def initialize(amount, currency=:euro)
+    self.amount = amount
+    self.currency = currency
+  end
+  def to_f() amount.to_f end
+  def ==(other) currency == other.currency && (amount - other.amount).abs/[amount.abs, other.amount.abs].max < 1e-10 end
+  def to_s() amount.to_s end
+end
+
+class Date
+  class << self
+    def to_french_human_input_converter_proc
+      proc { |value|
+        value = value.convert_to(Conversion::HumanInputString)
+        if value.nil?
+          nil
+        else
+          # "d/m/y" => date(y,m,d)
+          elements = value.split(/[-\/]/).convert_entries_to(Integer)
+          begin
+            Date.civil(elements[2], elements[1], elements[0])
+          rescue
+            value
+          end
+        end
+      }
+    end
+  end
+end
+
+class Test
+  include Conversion::Accessors
+  
+  attr_reader :base1
+  attr_writer :base1, :store_as => Conversion.converter(Integer)
+  attr_accessor :weak1, :store_as => Integer, :store_mode=>:weak
+  
+  store_attributes_with_mode :weak
+  
+  attr_accessor :weak2, :store_as => Integer
+  attr_accessor :base2, :store_as => Integer, :store_mode=>:base
+  
+  store_enumerable_attributes
+  
+  attr_accessor :weak_enumerable1, :store_as => Integer
+  attr_accessor :base_enumerable1, :store_as => Integer, :store_mode=>:base
+  attr_accessor :weak_enumerable2, :store_as => Conversion.converter(Integer, :mode=>:base)
+  
+  store_enumerable_attributes false
+
+  attr_accessor :base4, :store_as => Integer, :store_mode=>:base
+  attr_accessor :weak3, :store_as => Conversion.converter(Integer, :mode=>:base)
+
+  store_attributes_with_mode nil
+
+  attr_accessor :base5, :store_as => Integer
+  attr_accessor :base_enumerable3, :store_as => Conversion.entries_converter(Integer)
+
+  store_attributes_with_mode :weak
+
+  attr_accessor :weak_enumerable3, :store_as => Conversion.entries_converter(Integer)
+end
+
+test=Test.new
+symbol=:hello
+string=:hello.to_s
+fixnum=:hello.to_i
+bignum=12345678*12345678
+bigbignum=1234567890*1234567890
+float=fixnum+0.5
+bigfloat=bignum+0.5
+euro = Money.new(bigfloat, :euro)
+dollar = Money.new(float, :dollar)
+numbers = [[fixnum, float], [bignum, bigfloat]]
+integers = [[fixnum, fixnum+1], [bignum, bignum+1]]
+hash=Hash.new(fixnum)
+date = Date.civil(1973,9,18)
+objects = [nil, date, test, hash, symbol, string, fixnum, bignum, bigbignum, integers, numbers, float, euro, dollar]
+flat_objects = [nil, symbol, string, fixnum, bignum, bigbignum, float, date, euro]
+
+# tests are based on these assertions
+assert(bignum.to_f.to_i == bignum)
+assert(bigbignum.to_f.to_i != bigbignum)
+assert(float.to_i == fixnum)
+assert(bigfloat.to_i == bignum)
+assert(fixnum.to_sym == symbol)
+assert(symbol.to_s == string)
+assert(euro.to_f == bigfloat)
+assert(dollar.to_f == float)
+
+
+# Core
+# ----
+
+# object that can't be used as converters
+assert_exception(ArgumentError) { Conversion.converter(test).call(1) }
+assert_exception(ArgumentError) { Conversion.converter(nil).call(1) }
+assert_exception(ArgumentError) { Conversion.converter(fixnum).call(1) }
+
+# to_proc < to_converter_proc
+def test.to_proc() proc { |x| 'to_proc'} end
+assert(Conversion.converter(test).call(nil) == 'to_proc')
+def test.to_converter_proc() proc { |x| 'to_converter_proc'} end
+assert(Conversion.converter(test).call(nil) == 'to_converter_proc')
+
+# string conversion
+assert_exception(TypeError) { Conversion.converter('abc').call(1) }
+
+# symbol conversion
+objects.each { |x| assert(Conversion.converter(:inspect).call(x) == x.inspect) }
+
+# Symbol conversion
+assert_exception { Conversion.converter(Symbol).call(nil) }
+a = Conversion.converter(Integer).call(symbol)
+assert(Conversion.converter(Symbol).call(a) == symbol)
+assert(Conversion.converter(Symbol).call(symbol) == symbol)
+assert(Conversion.converter(Symbol).call(string) == symbol)
+assert_exception { Conversion.converter(Symbol).call(float) }
+
+# String conversion
+assert(Conversion.converter(String).call(nil) == '')
+assert(Conversion.converter(String).call(symbol) == string)
+
+# Integer conversion
+assert(Conversion.converter(Fixnum).call(nil) == 0)
+assert(Conversion.converter(Fixnum).call(fixnum.to_s) == fixnum)
+assert(Conversion.converter(Fixnum).call(bignum.to_s) == bignum)
+assert(Conversion.converter(Fixnum).call(bigbignum.to_s) == bigbignum)
+assert(Conversion.converter(Fixnum).call(float) == fixnum+1)
+assert(Conversion.converter(Fixnum).call(euro) == bignum+1)
+assert(Conversion.converter(Bignum).call(nil) == 0)
+assert(Conversion.converter(Bignum).call(fixnum.to_s) == fixnum)
+assert(Conversion.converter(Bignum).call(bignum.to_s) == bignum)
+assert(Conversion.converter(Bignum).call(bigbignum.to_s) == bigbignum)
+assert(Conversion.converter(Bignum).call(float) == fixnum+1)
+assert(Conversion.converter(Bignum).call(euro) == bignum+1)
+assert(Conversion.converter(Integer).call(nil) == 0)
+assert(Conversion.converter(Integer).call(fixnum.to_s) == fixnum)
+assert(Conversion.converter(Integer).call(bignum.to_s) == bignum)
+assert(Conversion.converter(Integer).call(bigbignum.to_s) == bigbignum)
+assert(Conversion.converter(Integer).call(float) == fixnum+1)
+assert(Conversion.converter(Integer).call(euro) == bignum+1)
+assert_exception { Conversion.converter(Integer).call(string) }
+
+# Float conversion
+assert(Conversion.converter(Float).call(float.to_s) == float)
+assert(Conversion.converter(Float).call(euro) == bigfloat)
+assert_exception { Conversion.converter(Float).call(string) }
+
+# Nil conversion
+objects.each { |x| assert(Conversion.converter(NilClass).call(x) == nil) }
+
+# Money conversion
+assert(Conversion.converter(Money).call(bigfloat, :euro) == euro)
+assert(Conversion.converter(Money).call(bigfloat) == euro)
+assert(Conversion.converter(Money).call(float, :dollar) == dollar)
+assert(Conversion.converter(Money).call(float.to_s, 'dollar') == dollar)
+
+# other classes conversion
+assert(Conversion.converter(Array).call(1) == [nil])
+assert(Conversion.converter(Hash).call(fixnum)[string] == fixnum)
+
+# enumerable conversion
+assert_exception { Conversion.converter(Integer).call(numbers) }
+assert(Conversion.entries_converter(Integer).call(numbers.flatten) == integers.flatten)
+assert(Conversion.entries_converter(Integer).call(numbers) == integers)
+hash[symbol] = bignum.to_s
+assert(Conversion.entries_converter(Integer).call(hash)[symbol] == bignum)
+assert(Conversion.entries_converter(Integer).call(hash)[euro] == fixnum)
+
+# Class stability
+objects.each { |x| assert(Conversion.converter(x.class).call(x).equal?(x)) }
+
+
+# Object decoration
+# -----------------
+
+assert(float.convert_to(Integer) == fixnum+1)
+
+# Conversion mode
+# ---------------
+
+assert_exception(ArgumentError) { nil.convert_to(Float, :mode=>:foo) }
+
+# stable nil
+# ----------
+
+assert(nil.convert_to(Integer) == 0)
+assert(nil.convert_to(Integer, :mode=>:stable_nil).nil?)
+assert(nil.convert_to(String) == '')
+assert(nil.convert_to(String, :mode=>:stable_nil).nil?)
+
+# nil on failure
+
+#assert(string.convert_to(Integer, :mode=>:nil_on_failure).nil?)
+assert(fixnum.convert_to(Bignum, :mode=>:nil_on_failure).nil?)
+assert(bignum.convert_to(Fixnum, :mode=>:nil_on_failure).nil?)
+
+# weak type checking
+# ------------------
+
+assert_exception { Conversion.converter(Float).call(string) }
+assert(nil.convert_to(Float, :mode=>:weak) == nil)
+assert(string.convert_to(Float, :mode=>:weak) == string)
+assert(float.to_s.convert_to(Float, :mode=>:weak) == float)
+assert([1, '2', 'a'].convert_entries_to(Integer, :mode=>:weak) == [1, 2, 'a'])
+
+# type checking before
+# --------------------
+
+assert(nil.convert_to(Float, :mode=>:strong_type_checking) == nil)
+assert(float.convert_to(Float, :mode=>:strong_type_checking) == float)
+assert_exception(ArgumentError) { float.to_s.convert_to(Float, :mode=>:strong_type_checking) }
+assert_exception(ArgumentError) { [1, '2', 'a'].convert_entries_to(Integer, :mode=>:strong_type_checking) }
+
+# human input
+# -----------
+
+assert(''.convert_to(String, :mode=>:human_input)==nil)
+assert(''.convert_to(Integer, :mode=>:human_input)==nil)
+assert(' '.convert_to(String, :mode=>:human_input)==nil)
+assert(' '.convert_to(Integer, :mode=>:human_input)==nil)
+assert("\t".convert_to(String, :mode=>:human_input)==nil)
+assert("\t".convert_to(Integer, :mode=>:human_input)==nil)
+assert("\n".convert_to(String, :mode=>:human_input)==nil)
+assert("\n".convert_to(Integer, :mode=>:human_input)==nil)
+assert(' '.convert_to(String, :mode=>:human_input)==nil)  # non-breaking space
+assert(' '.convert_to(Integer, :mode=>:human_input)==nil)
+
+assert('  1 234.5 '.convert_to(String, :mode=>:human_input)=='1234.5')
+assert('  1 234.5 '.convert_to(Float, :mode=>:human_input)==1234.5)
+assert('  1 234,5 '.convert_to(Integer, :mode=>:human_input)==1235)
+assert('  1 234, 5 '.convert_to(Integer, :mode=>:human_input)=='1 234, 5')
+assert('  1 234.5 ,6 '.convert_to(Integer, :mode=>:human_input)=='1 234.5 ,6')
+assert([1, '2', 'a'].convert_entries_to(Integer, :mode=>:human_input) == [1, 2, 'a'])
+
+assert(' '.convert_to(Date, :mode=>:human_input) == nil)
+assert('18/9/1973'.convert_to(Date, :mode=>:french_human_input) == date)
+
+flat_objects.each { |x| assert(Conversion.converter(x.class, :mode=>:human_input).call(x.convert_to(Conversion::HumanInputString)) == x) }
+
+# Accessor modes
+# --------------
+
+test.base1 = fixnum.to_s; assert(test.base1 == fixnum)
+assert_exception { test.base1 = string }
+assert_exception { test.base1 = [fixnum.to_s] }
+assert_exception { test.base1 = [string] }
+
+test.base2 = fixnum.to_s; assert(test.base2 == fixnum)
+assert_exception { test.base2 = string }
+assert_exception { test.base2 = [fixnum.to_s] }
+assert_exception { test.base2 = [string] }
+
+test.base4 = fixnum.to_s; assert(test.base4 == fixnum)
+assert_exception { test.base4 = string }
+assert_exception { test.base4 = [fixnum.to_s] }
+assert_exception { test.base4 = [string] }
+
+test.base5 = fixnum.to_s; assert(test.base5 == fixnum)
+assert_exception { test.base5 = string }
+assert_exception { test.base5 = [fixnum.to_s] }
+assert_exception { test.base5 = [string] }
+
+test.weak1 = fixnum.to_s; assert(test.weak1 == fixnum)
+test.weak1 = string; assert(test.weak1 == string)
+test.weak1 = [fixnum.to_s]; assert(test.weak1 == [fixnum.to_s])
+test.weak1 = [string]; assert(test.weak1 == [string])
+
+test.weak2 = fixnum.to_s; assert(test.weak2 == fixnum)
+test.weak2 = string; assert(test.weak2 == string)
+test.weak2 = [fixnum.to_s]; assert(test.weak2 == [fixnum.to_s])
+test.weak2 = [string]; assert(test.weak2 == [string])
+
+test.weak3 = fixnum.to_s; assert(test.weak3 == fixnum)
+test.weak3 = string; assert(test.weak3 == string)
+test.weak3 = [fixnum.to_s]; assert(test.weak3 == [fixnum.to_s])
+test.weak3 = [string]; assert(test.weak3 == [string])
+
+test.weak_enumerable1 = fixnum.to_s; assert(test.weak_enumerable1 == fixnum)
+test.weak_enumerable1 = string; assert(test.weak_enumerable1 == string)
+test.weak_enumerable1 = [fixnum.to_s]; assert(test.weak_enumerable1 == [fixnum])
+test.weak_enumerable1 = [string]; assert(test.weak_enumerable1 == [string])
+
+test.weak_enumerable2 = fixnum.to_s; assert(test.weak_enumerable2 == fixnum)
+test.weak_enumerable2 = string; assert(test.weak_enumerable2 == string)
+test.weak_enumerable2 = [fixnum.to_s]; assert(test.weak_enumerable2 == [fixnum])
+test.weak_enumerable2 = [string]; assert(test.weak_enumerable2 == [string])
+
+test.weak_enumerable3 = fixnum.to_s; assert(test.weak_enumerable3 == fixnum)
+test.weak_enumerable3 = string; assert(test.weak_enumerable3 == string)
+test.weak_enumerable3 = [fixnum.to_s]; assert(test.weak_enumerable3 == [fixnum])
+test.weak_enumerable3 = [string]; assert(test.weak_enumerable3 == [string])
+
+test.base_enumerable1 = fixnum.to_s; assert(test.base_enumerable1 == fixnum)
+assert_exception { test.base_enumerable1 = string }
+test.base_enumerable1 = [fixnum.to_s]; assert(test.base_enumerable1 == [fixnum])
+assert_exception { test.base_enumerable1 = [string] }
+
+test.base_enumerable3 = fixnum.to_s; assert(test.base_enumerable3 == fixnum)
+assert_exception { test.base_enumerable3 = string }
+test.base_enumerable3 = [fixnum.to_s]; assert(test.base_enumerable3 == [fixnum])
+assert_exception { test.base_enumerable3 = [string] }
+
+
+
+# -----------------
+
+puts "#{$assertions} assertions OK"

data/test/conversion_test.rb

@@ -0,0 +1,11 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class ConversionTest < Test::Unit::TestCase
+
+  def setup
+  end
+  
+  def test_truth
+    assert true
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,2 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/conversion'

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.11
+specification_version: 1
+name: conversion
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+date: 2006-10-22 00:00:00 +02:00
+summary: Conversion module obviously allows object conversion and extends attr_writer/accessor
+require_paths: 
+- lib
+email: gr@pierlis.com
+homepage: http://conversion.rubyforge.org
+rubyforge_project: conversion
+description: Conversion module obviously allows object conversion and extends attr_writer/accessor
+autorequire: conversion
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+authors: 
+- "Gwendal Rou\xC3\xA9"
+files: 
+- README
+- CHANGELOG
+- Rakefile
+- test/conversion_test.rb
+- test/test_helper.rb
+- lib/conversion
+- lib/conversion.rb
+- lib/conversion_test.rb
+- lib/conversion/accessors.rb
+- lib/conversion/class_decoration.rb
+- lib/conversion/core.rb
+- lib/conversion/mode
+- lib/conversion/object_decoration.rb
+- lib/conversion/version.rb
+- lib/conversion/mode/human_input
+- lib/conversion/mode/human_input.rb
+- lib/conversion/mode/nil_on_failure.rb
+- lib/conversion/mode/stable_nil.rb
+- lib/conversion/mode/strong_type_checking.rb
+- lib/conversion/mode/weak.rb
+- lib/conversion/mode/human_input/class_decoration.rb
+- lib/conversion/mode/human_input/core.rb
+test_files: []
+
+rdoc_options: 
+- --quiet
+- --title
+- conversion documentation
+- --opname
+- index.html
+- --line-numbers
+- --main
+- README
+- --inline-source
+- --exclude
+- ^(examples|extras)/
+extra_rdoc_files: 
+- README
+- CHANGELOG
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: []
+