summaryrefslogtreecommitdiff
path: root/jni/ruby/lib/yaml
diff options
context:
space:
mode:
Diffstat (limited to 'jni/ruby/lib/yaml')
-rw-r--r--jni/ruby/lib/yaml/dbm.rb279
-rw-r--r--jni/ruby/lib/yaml/store.rb81
2 files changed, 360 insertions, 0 deletions
diff --git a/jni/ruby/lib/yaml/dbm.rb b/jni/ruby/lib/yaml/dbm.rb
new file mode 100644
index 0000000..24a68bf
--- /dev/null
+++ b/jni/ruby/lib/yaml/dbm.rb
@@ -0,0 +1,279 @@
+require 'yaml'
+require 'dbm'
+
+module YAML
+
+# YAML + DBM = YDBM
+#
+# YAML::DBM provides the same interface as ::DBM.
+#
+# However, while DBM only allows strings for both keys and values,
+# this library allows one to use most Ruby objects for values
+# by first converting them to YAML. Keys must be strings.
+#
+# Conversion to and from YAML is performed automatically.
+#
+# See the documentation for ::DBM and ::YAML for more information.
+class DBM < ::DBM
+ VERSION = "0.1" # :nodoc:
+
+ # :call-seq:
+ # ydbm[key] -> value
+ #
+ # Return value associated with +key+ from database.
+ #
+ # Returns +nil+ if there is no such +key+.
+ #
+ # See #fetch for more information.
+ def []( key )
+ fetch( key )
+ end
+
+ # :call-seq:
+ # ydbm[key] = value
+ #
+ # Set +key+ to +value+ in database.
+ #
+ # +value+ will be converted to YAML before storage.
+ #
+ # See #store for more information.
+ def []=( key, val )
+ store( key, val )
+ end
+
+ # :call-seq:
+ # ydbm.fetch( key, ifnone = nil )
+ # ydbm.fetch( key ) { |key| ... }
+ #
+ # Return value associated with +key+.
+ #
+ # If there is no value for +key+ and no block is given, returns +ifnone+.
+ #
+ # Otherwise, calls block passing in the given +key+.
+ #
+ # See ::DBM#fetch for more information.
+ def fetch( keystr, ifnone = nil )
+ begin
+ val = super( keystr )
+ return YAML.load( val ) if String === val
+ rescue IndexError
+ end
+ if block_given?
+ yield keystr
+ else
+ ifnone
+ end
+ end
+
+ # Deprecated, used YAML::DBM#key instead.
+ # ----
+ # Note:
+ # YAML::DBM#index makes warning from internal of ::DBM#index.
+ # It says 'DBM#index is deprecated; use DBM#key', but DBM#key
+ # behaves not same as DBM#index.
+ #
+ def index( keystr )
+ super( keystr.to_yaml )
+ end
+
+ # :call-seq:
+ # ydbm.key(value) -> string
+ #
+ # Returns the key for the specified value.
+ def key( keystr )
+ invert[keystr]
+ end
+
+ # :call-seq:
+ # ydbm.values_at(*keys)
+ #
+ # Returns an array containing the values associated with the given keys.
+ def values_at( *keys )
+ keys.collect { |k| fetch( k ) }
+ end
+
+ # :call-seq:
+ # ydbm.delete(key)
+ #
+ # Deletes value from database associated with +key+.
+ #
+ # Returns value or +nil+.
+ def delete( key )
+ v = super( key )
+ if String === v
+ v = YAML.load( v )
+ end
+ v
+ end
+
+ # :call-seq:
+ # ydbm.delete_if { |key, value| ... }
+ #
+ # Calls the given block once for each +key+, +value+ pair in the database.
+ # Deletes all entries for which the block returns true.
+ #
+ # Returns +self+.
+ def delete_if # :yields: [key, value]
+ del_keys = keys.dup
+ del_keys.delete_if { |k| yield( k, fetch( k ) ) == false }
+ del_keys.each { |k| delete( k ) }
+ self
+ end
+
+ # :call-seq:
+ # ydbm.reject { |key, value| ... }
+ #
+ # Converts the contents of the database to an in-memory Hash, then calls
+ # Hash#reject with the specified code block, returning a new Hash.
+ def reject
+ hsh = self.to_hash
+ hsh.reject { |k,v| yield k, v }
+ end
+
+ # :call-seq:
+ # ydbm.each_pair { |key, value| ... }
+ #
+ # Calls the given block once for each +key+, +value+ pair in the database.
+ #
+ # Returns +self+.
+ def each_pair # :yields: [key, value]
+ keys.each { |k| yield k, fetch( k ) }
+ self
+ end
+
+ # :call-seq:
+ # ydbm.each_value { |value| ... }
+ #
+ # Calls the given block for each value in database.
+ #
+ # Returns +self+.
+ def each_value # :yields: value
+ super { |v| yield YAML.load( v ) }
+ self
+ end
+
+ # :call-seq:
+ # ydbm.values
+ #
+ # Returns an array of values from the database.
+ def values
+ super.collect { |v| YAML.load( v ) }
+ end
+
+ # :call-seq:
+ # ydbm.has_value?(value)
+ #
+ # Returns true if specified +value+ is found in the database.
+ def has_value?( val )
+ each_value { |v| return true if v == val }
+ return false
+ end
+
+ # :call-seq:
+ # ydbm.invert -> hash
+ #
+ # Returns a Hash (not a DBM database) created by using each value in the
+ # database as a key, with the corresponding key as its value.
+ #
+ # Note that all values in the hash will be Strings, but the keys will be
+ # actual objects.
+ def invert
+ h = {}
+ keys.each { |k| h[ self.fetch( k ) ] = k }
+ h
+ end
+
+ # :call-seq:
+ # ydbm.replace(hash) -> ydbm
+ #
+ # Replaces the contents of the database with the contents of the specified
+ # object. Takes any object which implements the each_pair method, including
+ # Hash and DBM objects.
+ def replace( hsh )
+ clear
+ update( hsh )
+ end
+
+ # :call-seq:
+ # ydbm.shift -> [key, value]
+ #
+ # Removes a [key, value] pair from the database, and returns it.
+ # If the database is empty, returns +nil+.
+ #
+ # The order in which values are removed/returned is not guaranteed.
+ def shift
+ a = super
+ a[1] = YAML.load( a[1] ) if a
+ a
+ end
+
+ # :call-seq:
+ # ydbm.select { |key, value| ... }
+ # ydbm.select(*keys)
+ #
+ # If a block is provided, returns a new array containing [key, value] pairs
+ # for which the block returns true.
+ #
+ # Otherwise, same as #values_at
+ def select( *keys )
+ if block_given?
+ self.keys.collect { |k| v = self[k]; [k, v] if yield k, v }.compact
+ else
+ values_at( *keys )
+ end
+ end
+
+ # :call-seq:
+ # ydbm.store(key, value) -> value
+ #
+ # Stores +value+ in database with +key+ as the index. +value+ is converted
+ # to YAML before being stored.
+ #
+ # Returns +value+
+ def store( key, val )
+ super( key, val.to_yaml )
+ val
+ end
+
+ # :call-seq:
+ # ydbm.update(hash) -> ydbm
+ #
+ # Updates the database with multiple values from the specified object.
+ # Takes any object which implements the each_pair method, including
+ # Hash and DBM objects.
+ #
+ # Returns +self+.
+ def update( hsh )
+ hsh.each_pair do |k,v|
+ self.store( k, v )
+ end
+ self
+ end
+
+ # :call-seq:
+ # ydbm.to_a -> array
+ #
+ # Converts the contents of the database to an array of [key, value] arrays,
+ # and returns it.
+ def to_a
+ a = []
+ keys.each { |k| a.push [ k, self.fetch( k ) ] }
+ a
+ end
+
+
+ # :call-seq:
+ # ydbm.to_hash -> hash
+ #
+ # Converts the contents of the database to an in-memory Hash object, and
+ # returns it.
+ def to_hash
+ h = {}
+ keys.each { |k| h[ k ] = self.fetch( k ) }
+ h
+ end
+
+ alias :each :each_pair
+end
+
+end
diff --git a/jni/ruby/lib/yaml/store.rb b/jni/ruby/lib/yaml/store.rb
new file mode 100644
index 0000000..b0b580b
--- /dev/null
+++ b/jni/ruby/lib/yaml/store.rb
@@ -0,0 +1,81 @@
+#
+# YAML::Store
+#
+require 'yaml'
+require 'pstore'
+
+# YAML::Store provides the same functionality as PStore, except it uses YAML
+# to dump objects instead of Marshal.
+#
+# == Example
+#
+# require 'yaml/store'
+#
+# Person = Struct.new :first_name, :last_name
+#
+# people = [Person.new("Bob", "Smith"), Person.new("Mary", "Johnson")]
+#
+# store = YAML::Store.new "test.store"
+#
+# store.transaction do
+# store["people"] = people
+# store["greeting"] = { "hello" => "world" }
+# end
+#
+# After running the above code, the contents of "test.store" will be:
+#
+# ---
+# people:
+# - !ruby/struct:Person
+# first_name: Bob
+# last_name: Smith
+# - !ruby/struct:Person
+# first_name: Mary
+# last_name: Johnson
+# greeting:
+# hello: world
+
+class YAML::Store < PStore
+
+ # :call-seq:
+ # initialize( file_name, yaml_opts = {} )
+ #
+ # Creates a new YAML::Store object, which will store data in +file_name+.
+ # If the file does not already exist, it will be created.
+ #
+ #
+ # Options passed in through +yaml_opts+ will be used when converting the
+ # store to YAML via Hash#to_yaml().
+ def initialize file_name, yaml_opts = {}
+ @opt = yaml_opts
+ super
+ end
+
+ # :stopdoc:
+
+ def dump(table)
+ YAML.dump @table
+ end
+
+ def load(content)
+ table = YAML.load(content)
+ if table == false
+ {}
+ else
+ table
+ end
+ end
+
+ def marshal_dump_supports_canonical_option?
+ false
+ end
+
+ EMPTY_MARSHAL_DATA = YAML.dump({})
+ EMPTY_MARSHAL_CHECKSUM = Digest::MD5.digest(EMPTY_MARSHAL_DATA)
+ def empty_marshal_data
+ EMPTY_MARSHAL_DATA
+ end
+ def empty_marshal_checksum
+ EMPTY_MARSHAL_CHECKSUM
+ end
+end