storable 0.8.6 → 0.9.pre.RC2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1fe040169d9300d29f3a00c5e46e74580a6f5a124b6dabda16ad3a8132d5a6eb
+  data.tar.gz: 24de9dc3bf471ef05c6aad494482925131f0b00d3a4f3dff5f478eec4b655dee
+SHA512:
+  metadata.gz: fdaa8dc26da7cf8163dcb1d5d6249a894816445fdf0309bff690e0fc70cc13b637bf3d9ae0557d5eec2a6cabe32986b318a683b3529b0fdee466b733e1c11afb
+  data.tar.gz: 363d57e409178dac08aac9809768d6a1cfb7e4bccf2056be267da51718cc505219eb5a182a41cb3b87be2d5b4d569506dbbe473ee082e4ce8c3162f9cd9ccda7

data/{README.rdoc → README.md}

@@ -1,76 +1,76 @@
-= Storable - v0.8
+# Storable - v0.9-RC2
 
-Marshal Ruby classes into and out of multiple formats (yaml, json, csv, tsv)
+Marshal Ruby classes in to and out of multiple formats (yaml, json, csv, tsv).
+
+## Example
 
-== Example
-    
     require 'storable'
-    
+
     class Machine < Storable
       field :environment            # Define field names for Machine. The
       field :role                   # default type is String, but you can
       field :position => Integer    # specify a type using a hash syntax.
     end
-    
+
     mac1 = Machine.new              # Instances of Machine have accessors
-    mac1.environment = "stage"      # just like regular attributes. 
+    mac1.environment = "stage"      # just like regular attributes.
     mac1.role = "app"
     mac1.position = 1
-    
-    puts "# YAML", mac1.to_yaml     # Note: the field order is maintained     
+
+    puts "# YAML", mac1.to_yaml     # Note: the field order is maintained
     puts "# CSV", mac1.to_csv       # => stage,app,1
     puts "# JSON", mac1.to_json     # Note: field order not maintained.
-    
+
     mac2 = Machine.from_yaml(mac1.to_yaml)
     puts mac2.environment           # => "stage"
     puts mac2.position.class        # => Fixnum
 
 
-== Sensitive Fields
+## Sensitive Fields
 
     require 'storable'
-    
+
     class Calc < Storable
       field :three
       field :two
       field :one
       sensitive_fields :three
     end
-    
+
     calc = Calc.new 3, 2, 1
     calc.to_a                       # => [3, 2, 1]
     calc.sensitive!
     calc.to_a                       # => [2, 1]
-    
-    
-== Storing Procs
 
-Storable can also marshal Proc objects to and from their actual source code. 
-    
+
+## Storing Procs
+
+Storable can also marshal Proc objects to and from their actual source code.
+
     require 'storable'
-    
+
     class Maths < Storable
       field :x         => Float
       field :y         => Float
       field :calculate => Proc
     end
-    
+
     m1 = Maths.new 2.0, 3.0
     m1.calculate = Proc.new { @x * @y }
-    
+
     m1.calculate.source            # => "{ @x * @y }"
     m1.call :calculate             # => 6.0
-    
+
     dump = m1.to_json
-    
+
     m2 = Maths.from_json dump
     m2.call :calculate             # => 6.0
-    
-   
-Anything is possible when you keep your mind open and you use Ruby. 
 
 
-== Installation
+Anything is possible when you keep your mind open and you use Ruby.
+
+
+## Installation
 
 Via Rubygems, one of:
 
@@ -80,29 +80,30 @@ Via Rubygems, one of:
 or via download:
 * storable-latest.tar.gz[http://github.com/delano/storable/tarball/latest]
 * storable-latest.zip[http://github.com/delano/storable/zipball/latest]
- 
 
-== Prerequisites
 
-* Ruby 1.8, Ruby 1.9, or JRuby 1.2+
+## Prerequisites
+
+* Ruby <=2.7, >=1.9, possibly JRuby
 
 
-== Credits
+## Credits
 
 * Delano Mandelbaum (delano@solutious.com)
 * lib/proc_source.rb is based on http://github.com/imedo/background
 * OrderedHash implementation by Jan Molic
 
 
-== Thanks
+## Thanks
 
-* Pierre Riteau (priteau[http://github.com/priteau]) for bug fixes. 
+* Pierre Riteau (priteau[https://github.com/priteau]) for bug fixes.
+* notro[https://github.com/priteau] for proc_source improvements.
 
 
-== More Info
+## More Info
 
-* Codes[http://github.com/delano/storable]
+* GitHub[http://github.com/delano/storable]
 
-== License
+## License
 
-See: LICENSE.txt
+See: LICENSE.txt

data/Rakefile

@@ -1,22 +1,17 @@
 require 'rubygems'
 require 'rake/clean'
-require 'rake/gempackagetask'
+require 'rubygems/package_task'
 require 'fileutils'
+require 'rdoc/task'
 include FileUtils
 
-begin
-  require 'hanna/rdoctask'
-rescue LoadError
-  require 'rake/rdoctask'
-end
-
 task :default => :package
- 
+
+
 # CONFIG =============================================================
 
 # Change the following according to your needs
-README = "README.rdoc"
-CHANGES = "CHANGES.txt"
+README = "README.md"
 LICENSE = "LICENSE.txt"
 
 # Files and directories to be deleted when you run "rake clean"
@@ -28,20 +23,22 @@ load "#{name}.gemspec"
 version = @spec.version
 
 # That's it! The following defaults should allow you to get started
-# on other things. 
+# on other things.
 
 
 # TESTS/SPECS =========================================================
 
-
+task :test do
+	sh "try"
+end
 
 # INSTALL =============================================================
 
-Rake::GemPackageTask.new(@spec) do |p|
+Gem::PackageTask.new(@spec) do |p|
   p.need_tar = true if RUBY_PLATFORM !~ /mswin/
 end
 
-task :build => [ :package ]
+task :build => [ :test, :package ]
 task :release => [ :rdoc, :package ]
 task :install => [ :rdoc, :package ] do
 	sh %{sudo gem install pkg/#{name}-#{version}.gem}
@@ -51,65 +48,15 @@ task :uninstall => [ :clean ] do
 end
 
 
-# RUBYFORGE RELEASE / PUBLISH TASKS ==================================
-
-if @spec.rubyforge_project
-  desc 'Publish website to rubyforge'
-  task 'publish:rdoc' => 'doc/index.html' do
-    sh "scp -rp doc/* rubyforge.org:/var/www/gforge-projects/#{name}/"
-  end
-
-  desc 'Public release to rubyforge'
-  task 'publish:gem' => [:package] do |t|
-    sh <<-end
-      rubyforge add_release -o Any -a #{CHANGES} -f -n #{README} #{name} #{name} #{@spec.version} pkg/#{name}-#{@spec.version}.gem &&
-      rubyforge add_file -o Any -a #{CHANGES} -f -n #{README} #{name} #{name} #{@spec.version} pkg/#{name}-#{@spec.version}.tgz 
-    end
-  end
-end
-
-
-
 # RUBY DOCS TASK ==================================
-begin
-  require 'hanna/rdoctask'
-rescue LoadError
-  require 'rake/rdoctask'
-end
 
-Rake::RDocTask.new do |t|
+RDoc::Task.new do |t|
 	t.rdoc_dir = 'doc'
 	t.title    = @spec.summary
 	t.options << '--line-numbers' << '--inline-source' << '-A cattr_accessor=object'
 	t.options << '--charset' << 'utf-8'
 	t.rdoc_files.include(LICENSE)
 	t.rdoc_files.include(README)
-	t.rdoc_files.include(CHANGES)
 	#t.rdoc_files.include('bin/*')
 	t.rdoc_files.include('lib/**/*.rb')
 end
-
-
-
-
-#Hoe.new('rspec', Spec::VERSION::STRING) do |p|
-#  p.summary = Spec::VERSION::SUMMARY
-#  p.description = "Behaviour Driven Development for Ruby."
-#  p.rubyforge_name = 'rspec'
-#  p.developer('RSpec Development Team', 'rspec-devel@rubyforge.org')
-#  p.extra_dev_deps = [["cucumber",">= 0.1.13"]]
-#  p.remote_rdoc_dir = "rspec/#{Spec::VERSION::STRING}"
-#  p.rspec_options = ['--options', 'spec/spec.opts']
-#  p.history_file = 'History.rdoc'
-#  p.readme_file  = 'README.rdoc'
-#  p.post_install_message = <<-POST_INSTALL_MESSAGE
-##{'*'*50}
-#
-#  Thank you for installing rspec-#{Spec::VERSION::STRING}
-#
-#  Please be sure to read History.rdoc and Upgrade.rdoc
-#  for useful information about this release.
-#
-#{'*'*50}
-#POST_INSTALL_MESSAGE
-#end

data/lib/core_ext.rb

@@ -0,0 +1,273 @@
+
+#
+# RubyToken was removed in >= 2.7
+# Direct copy from Ruby 2.6.6 source
+#
+
+# frozen_string_literal: false
+#
+#   irb/ruby-token.rb - ruby tokens
+#     $Release Version: 0.9.6$
+#     $Revision$
+#     by Keiju ISHITSUKA(keiju@ruby-lang.org)
+#
+# --
+#
+#
+#
+# :stopdoc:
+module RubyToken
+  EXPR_BEG = :EXPR_BEG
+  EXPR_MID = :EXPR_MID
+  EXPR_END = :EXPR_END
+  EXPR_ARG = :EXPR_ARG
+  EXPR_FNAME = :EXPR_FNAME
+  EXPR_DOT = :EXPR_DOT
+  EXPR_CLASS = :EXPR_CLASS
+
+  class Token
+    def initialize(seek, line_no, char_no)
+      @seek = seek
+      @line_no = line_no
+      @char_no = char_no
+    end
+    attr_reader :seek, :line_no, :char_no
+  end
+
+  class TkNode < Token
+    def initialize(seek, line_no, char_no)
+      super
+    end
+    attr_reader :node
+  end
+
+  class TkId < Token
+    def initialize(seek, line_no, char_no, name)
+      super(seek, line_no, char_no)
+      @name = name
+    end
+    attr_reader :name
+  end
+
+  class TkVal < Token
+    def initialize(seek, line_no, char_no, value = nil)
+      super(seek, line_no, char_no)
+      @value = value
+    end
+    attr_reader :value
+  end
+
+  class TkOp < Token
+    attr_accessor :name
+  end
+
+  class TkOPASGN < TkOp
+    def initialize(seek, line_no, char_no, op)
+      super(seek, line_no, char_no)
+      op = TkReading2Token[op][0] unless op.kind_of?(Symbol)
+      @op = op
+    end
+    attr_reader :op
+  end
+
+  class TkUnknownChar < Token
+    def initialize(seek, line_no, char_no, id)
+      super(seek, line_no, char_no)
+      @name = name
+    end
+    attr_reader :name
+  end
+
+  class TkError < Token
+  end
+
+  def Token(token, value = nil)
+    case token
+    when String
+      if (tk = TkReading2Token[token]).nil?
+        IRB.fail TkReading2TokenNoKey, token
+      end
+      tk = Token(tk[0], value)
+      if tk.kind_of?(TkOp)
+        tk.name = token
+      end
+      return tk
+    when Symbol
+      if (tk = TkSymbol2Token[token]).nil?
+        IRB.fail TkSymbol2TokenNoKey, token
+      end
+      return Token(tk[0], value)
+    else
+      if (token.ancestors & [TkId, TkVal, TkOPASGN, TkUnknownChar]).empty?
+        token.new(@prev_seek, @prev_line_no, @prev_char_no)
+      else
+        token.new(@prev_seek, @prev_line_no, @prev_char_no, value)
+      end
+    end
+  end
+
+  TokenDefinitions = [
+    [:TkCLASS,      TkId,  "class",  EXPR_CLASS],
+    [:TkMODULE,     TkId,  "module", EXPR_BEG],
+    [:TkDEF,      TkId,  "def",    EXPR_FNAME],
+    [:TkUNDEF,      TkId,  "undef",  EXPR_FNAME],
+    [:TkBEGIN,      TkId,  "begin",  EXPR_BEG],
+    [:TkRESCUE,     TkId,  "rescue", EXPR_MID],
+    [:TkENSURE,     TkId,  "ensure", EXPR_BEG],
+    [:TkEND,      TkId,  "end",    EXPR_END],
+    [:TkIF,         TkId,  "if",     EXPR_BEG, :TkIF_MOD],
+    [:TkUNLESS,     TkId,  "unless", EXPR_BEG, :TkUNLESS_MOD],
+    [:TkTHEN,     TkId,  "then",   EXPR_BEG],
+    [:TkELSIF,      TkId,  "elsif",  EXPR_BEG],
+    [:TkELSE,     TkId,  "else",   EXPR_BEG],
+    [:TkCASE,     TkId,  "case",   EXPR_BEG],
+    [:TkWHEN,     TkId,  "when",   EXPR_BEG],
+    [:TkWHILE,      TkId,  "while",  EXPR_BEG, :TkWHILE_MOD],
+    [:TkUNTIL,      TkId,  "until",  EXPR_BEG, :TkUNTIL_MOD],
+    [:TkFOR,      TkId,  "for",    EXPR_BEG],
+    [:TkBREAK,      TkId,  "break",  EXPR_END],
+    [:TkNEXT,     TkId,  "next",   EXPR_END],
+    [:TkREDO,     TkId,  "redo",   EXPR_END],
+    [:TkRETRY,      TkId,  "retry",  EXPR_END],
+    [:TkIN,     TkId,  "in",     EXPR_BEG],
+    [:TkDO,     TkId,  "do",     EXPR_BEG],
+    [:TkRETURN,     TkId,  "return", EXPR_MID],
+    [:TkYIELD,      TkId,  "yield",  EXPR_END],
+    [:TkSUPER,      TkId,  "super",  EXPR_END],
+    [:TkSELF,     TkId,  "self",   EXPR_END],
+    [:TkNIL,      TkId,  "nil",    EXPR_END],
+    [:TkTRUE,     TkId,  "true",   EXPR_END],
+    [:TkFALSE,      TkId,  "false",  EXPR_END],
+    [:TkAND,      TkId,  "and",    EXPR_BEG],
+    [:TkOR,       TkId,  "or",     EXPR_BEG],
+    [:TkNOT,      TkId,  "not",    EXPR_BEG],
+    [:TkIF_MOD,     TkId],
+    [:TkUNLESS_MOD, TkId],
+    [:TkWHILE_MOD,  TkId],
+    [:TkUNTIL_MOD,  TkId],
+    [:TkALIAS,      TkId,  "alias",    EXPR_FNAME],
+    [:TkDEFINED,    TkId,  "defined?", EXPR_END],
+    [:TklBEGIN,     TkId,  "BEGIN",    EXPR_END],
+    [:TklEND,     TkId,  "END",      EXPR_END],
+    [:Tk__LINE__,   TkId,  "__LINE__", EXPR_END],
+    [:Tk__FILE__,   TkId,  "__FILE__", EXPR_END],
+
+    [:TkIDENTIFIER, TkId],
+    [:TkFID,      TkId],
+    [:TkGVAR,     TkId],
+    [:TkCVAR,     TkId],
+    [:TkIVAR,     TkId],
+    [:TkCONSTANT,   TkId],
+
+    [:TkINTEGER,    TkVal],
+    [:TkFLOAT,      TkVal],
+    [:TkSTRING,     TkVal],
+    [:TkXSTRING,    TkVal],
+    [:TkREGEXP,     TkVal],
+    [:TkSYMBOL,     TkVal],
+
+    [:TkDSTRING,    TkNode],
+    [:TkDXSTRING,   TkNode],
+    [:TkDREGEXP,    TkNode],
+    [:TkNTH_REF,    TkNode],
+    [:TkBACK_REF,   TkNode],
+
+    [:TkUPLUS,      TkOp,   "+@"],
+    [:TkUMINUS,     TkOp,   "-@"],
+    [:TkPOW,      TkOp,   "**"],
+    [:TkCMP,      TkOp,   "<=>"],
+    [:TkEQ,     TkOp,   "=="],
+    [:TkEQQ,      TkOp,   "==="],
+    [:TkNEQ,      TkOp,   "!="],
+    [:TkGEQ,      TkOp,   ">="],
+    [:TkLEQ,      TkOp,   "<="],
+    [:TkANDOP,      TkOp,   "&&"],
+    [:TkOROP,     TkOp,   "||"],
+    [:TkMATCH,      TkOp,   "=~"],
+    [:TkNMATCH,     TkOp,   "!~"],
+    [:TkDOT2,     TkOp,   ".."],
+    [:TkDOT3,     TkOp,   "..."],
+    [:TkAREF,     TkOp,   "[]"],
+    [:TkASET,     TkOp,   "[]="],
+    [:TkLSHFT,      TkOp,   "<<"],
+    [:TkRSHFT,      TkOp,   ">>"],
+    [:TkCOLON2,     TkOp],
+    [:TkCOLON3,     TkOp],
+    [:TkASSOC,      TkOp,   "=>"],
+    [:TkQUESTION,   TkOp,   "?"],  #?
+    [:TkCOLON,      TkOp,   ":"],        #:
+
+    [:TkfLPAREN],         # func( #
+    [:TkfLBRACK],         # func[ #
+    [:TkfLBRACE],         # func{ #
+    [:TkSTAR],            # *arg
+    [:TkAMPER],           # &arg #
+    [:TkSYMBEG],          # :SYMBOL
+
+    [:TkGT,     TkOp,   ">"],
+    [:TkLT,     TkOp,   "<"],
+    [:TkPLUS,     TkOp,   "+"],
+    [:TkMINUS,      TkOp,   "-"],
+    [:TkMULT,     TkOp,   "*"],
+    [:TkDIV,      TkOp,   "/"],
+    [:TkMOD,      TkOp,   "%"],
+    [:TkBITOR,      TkOp,   "|"],
+    [:TkBITXOR,     TkOp,   "^"],
+    [:TkBITAND,     TkOp,   "&"],
+    [:TkBITNOT,     TkOp,   "~"],
+    [:TkNOTOP,      TkOp,   "!"],
+
+    [:TkBACKQUOTE,  TkOp,   "`"],
+
+    [:TkASSIGN,     Token,  "="],
+    [:TkDOT,      Token,  "."],
+    [:TkLPAREN,     Token,  "("],  #(exp)
+    [:TkLBRACK,     Token,  "["],  #[arry]
+    [:TkLBRACE,     Token,  "{"],  #{hash}
+    [:TkRPAREN,     Token,  ")"],
+    [:TkRBRACK,     Token,  "]"],
+    [:TkRBRACE,     Token,  "}"],
+    [:TkCOMMA,      Token,  ","],
+    [:TkSEMICOLON,  Token,  ";"],
+
+    [:TkCOMMENT],
+    [:TkRD_COMMENT],
+    [:TkSPACE],
+    [:TkNL],
+    [:TkEND_OF_SCRIPT],
+
+    [:TkBACKSLASH,  TkUnknownChar,  "\\"],
+    [:TkAT,     TkUnknownChar,  "@"],
+    [:TkDOLLAR,     TkUnknownChar,  "$"],
+  ]
+
+  # {reading => token_class}
+  # {reading => [token_class, *opt]}
+  TkReading2Token = {}
+  TkSymbol2Token = {}
+
+  def RubyToken.def_token(token_n, super_token = Token, reading = nil, *opts)
+    token_n = token_n.id2name if token_n.kind_of?(Symbol)
+    if RubyToken.const_defined?(token_n)
+      IRB.fail AlreadyDefinedToken, token_n
+    end
+    token_c = eval("class #{token_n} < #{super_token}; end; #{token_n}")
+
+    if reading
+      if TkReading2Token[reading]
+        IRB.fail TkReading2TokenDuplicateError, token_n, reading
+      end
+      if opts.empty?
+        TkReading2Token[reading] = [token_c]
+      else
+        TkReading2Token[reading] = [token_c].concat(opts)
+      end
+    end
+    TkSymbol2Token[token_n.intern] = token_c
+  end
+
+  for defs in TokenDefinitions
+    def_token(*defs)
+  end
+end
+# :startdoc: