Class: JsshObject
Direct Known Subclasses
Instance Attribute Summary collapse
-
#debug_name ⇒ Object
readonly
Returns the value of attribute debug_name.
-
#function_result ⇒ Object
readonly
Returns the value of attribute function_result.
-
#jssh_socket ⇒ Object
readonly
Returns the value of attribute jssh_socket.
-
#ref ⇒ Object
readonly
Returns the value of attribute ref.
-
#type ⇒ Object
readonly
returns javascript typeof this object.
Instance Method Summary collapse
- #%(operand) ⇒ Object
- #*(operand) ⇒ Object
- #+(operand) ⇒ Object
- #-(operand) ⇒ Object
- #/(operand) ⇒ Object
- #<(operand) ⇒ Object
- #<=(operand) ⇒ Object
- #==(operand) ⇒ Object
- #>(operand) ⇒ Object
- #>=(operand) ⇒ Object
-
#[](key) ⇒ Object
returns a JsshObject referring to a subscript of this object, or a value if it is simple (see #val_or_object) subscript is specified as ruby (converted to_jssh).
-
#[]=(key, value) ⇒ Object
assigns the given ruby value (passed through json via JsshSocket#assign_json) to the given subscript (key is converted to_jssh).
-
#assign(val) ⇒ Object
assigns (via JsshSocket#assign) the given ruby value (converted to_jssh) to the reference for this object.
-
#assign_expr(val) ⇒ Object
assigns the given javascript expression (string) to the reference for this object.
-
#attr(attribute) ⇒ Object
returns a JsshObject referencing the given attribute of this object.
-
#binary_operator(operator, operand) ⇒ Object
calls a binary operator with self and another operand.
-
#call(*args) ⇒ Object
returns the value (via JsshSocket#value_json) or a JsshObject (see #val_or_object) of the return value of this function (assumes this object is a function) passing it the given arguments (which are converted to_jssh).
- #define_methods! ⇒ Object
- #id(*args) ⇒ Object
- #implemented_interfaces ⇒ Object
-
#initialize(ref, jssh_socket, other = {}) ⇒ JsshObject
constructor
initializes a JsshObject with a string of javascript containing a reference to the object, and a JsshSocket that the object is defined on.
- #inspect ⇒ Object
-
#instanceof(interface) ⇒ Object
returns javascript instanceof operator on this and the given interface (expected to be a JsshObject) note that this is javascript, not to be confused with ruby’s #instance_of? method.
-
#invoke(attribute, *args) ⇒ Object
returns a JsshObject representing the given attribute.
-
#method_missing(method, *args) ⇒ Object
method_missing handles unknown method calls in a way that makes it possible to write javascript-like syntax in ruby, to some extent.
- #object_respond_to?(method) ⇒ Boolean
-
#object_type ⇒ Object
returns the type of object that is reported by the javascript toString() method, which returns such as “[object Object]” or “[object XPCNativeWrapper [object HTMLDocument]]” This method returns ‘Object’ or ‘XPCNativeWrapper [object HTMLDocument]’ respectively.
-
#pass(*args) ⇒ Object
returns a JsshObject for this object - assumes that this object is a function - passing this function the specified arguments, which are converted to_jssh.
- #pretty_print(pp) ⇒ Object
- #respond_to?(method) ⇒ Boolean
-
#store(js_variable, somewhere_meaningful = true) ⇒ Object
sets the given javascript variable to this object, and returns a JsshObject referring to the variable.
- #store_rand_named(&name_proc) ⇒ Object
- #store_rand_object_key(object) ⇒ Object
- #store_rand_prefix(prefix) ⇒ Object
- #store_rand_temp ⇒ Object
-
#sub(key) ⇒ Object
returns a JsshObject referring to a subscript of this object, specified as a ruby object converted to javascript via to_jssh.
- #to_array ⇒ Object
- #to_dom ⇒ Object
- #to_hash ⇒ Object
- #to_js_array ⇒ Object
- #to_js_hash ⇒ Object
- #to_js_hash_safe ⇒ Object
-
#to_json(options = {}) ⇒ Object
this still needs to be defined because when ActiveSupport::JSON.encode is called by to_jssh on an array or hash containing a JsshObject, it calls to_json.
-
#to_jssh ⇒ Object
gives a reference for this object.
- #to_ruby_hash(options = {}) ⇒ Object
-
#val ⇒ Object
returns the value, via JsshSocket#value_json.
- #val_or_object(options = {}) ⇒ Object
-
#val_str ⇒ Object
returns the value just as a string with no attempt to deal with type using json.
Constructor Details
#initialize(ref, jssh_socket, other = {}) ⇒ JsshObject
initializes a JsshObject with a string of javascript containing a reference to the object, and a JsshSocket that the object is defined on.
563 564 565 566 567 568 569 570 571 572 573 |
# File 'lib/vapir-firefox/jssh_socket.rb', line 563 def initialize(ref, jssh_socket, other={}) other={:debug_name => ref, :function_result => false}.merge(other) raise ArgumentError, "Empty object reference!" if !ref || ref=='' raise ArgumentError, "Reference must be a string - got #{ref.inspect} (#{ref.class.name})" unless ref.is_a?(String) raise ArgumentError, "Not given a JsshSocket, instead given #{jssh_socket.inspect} (#{jssh_socket.class.name})" unless jssh_socket.is_a?(JsshSocket) @ref=ref @jssh_socket=jssh_socket @debug_name=other[:debug_name] @function_result=other[:function_result] # logger.info { "#{self.class} initialized: #{debug_name} (type #{type})" } end |
Dynamic Method Handling
This class handles dynamic methods through the method_missing method
#method_missing(method, *args) ⇒ Object
method_missing handles unknown method calls in a way that makes it possible to write javascript-like syntax in ruby, to some extent.
method_missing will only try to deal with methods that look like /^[a-z_]*$/i - no special characters, only alphanumeric/underscores, starting with alpha or underscore - with the exception of three special behaviors:
If the method ends with an equals sign (=), it does assignment - it calls JsshSocket#assign_json to do the assignment and returns the assigned value.
If the method ends with a bang (!), then it will attempt to get the value (using json) of the reference, using JsonObject#val. For simple types (null, string, boolean, number), this is what happens by default anyway, but if you have an object or an array that you know you can json-ize, you can use ! to force that. See #invoke documentation for more information.
If the method ends with a question mark (?), then it will attempt to get a string representing the value, using JsonObject#val_str. This is safer than ! because the javascript conversion to json can error. This also catches the JsshUndefinedValueError that can occur, and just returns nil for undefined stuff.
otherwise, method_missing calls to #invoke, and returns a JsshObject, a string, a boolean, a number, or null - see documentation for #invoke.
Since #invoke returns a JsshObject for javascript objects, this means that you can string together method_missings and the result looks rather like javascript.
this lets you do things like: >> jssh_socket.object(‘getWindows()’).length
> 2
>> jssh_socket.object(‘getWindows()’).getBrowser.contentDocument?
> “[object XPCNativeWrapper [object HTMLDocument]]”
>> document=jssh_socket.object(‘getWindows()’).getBrowser.contentDocument
> #<JsshObject:0x34f01fc @ref=“getWindows().getBrowser().contentDocument” …>
>> document.title
> “ruby - Google Search”
>> document.forms.q.value
> “ruby”
>> document.forms.q.value=‘foobar’
> “foobar”
>> document.forms.q.value
> “foobar”
$A and $H, used below, are methods of the Prototype javascript library, which add nice functional methods to arrays and hashes - see www.prototypejs.org/ You can use these methods with method_missing just like any other:
>> js_hash=jssh_socket.object(‘$H’)
> #<JsshObject:0x2beb598 @ref=“$H” …>
>> js_arr=jssh_socket.object(‘$A’)
> #<JsshObject:0x2be40e0 @ref=“$A” …>
>> js_arr.pass(document.body.childNodes).pluck! :tagName
> [“TEXTAREA”, “DIV”, “NOSCRIPT”, “DIV”, “DIV”, “DIV”, “BR”, “TABLE”, “DIV”, “DIV”, “DIV”, “TEXTAREA”, “DIV”, “DIV”, “SCRIPT”]
>> js_arr.pass(document.body.childNodes).pluck! :id
> [“csi”, “header”, “”, “ssb”, “tbd”, “res”, “”, “nav”, “wml”, “”, “”, “hcache”, “xjsd”, “xjsi”, “”]
>> js_hash.pass(document.getElementById(‘tbd’)).keys!
> [“addEventListener”, “appendChild”, “className”, “parentNode”, “getElementsByTagName”, “title”, “style”, “innerHTML”, “nextSibling”, “tagName”, “id”, “nodeName”, “nodeValue”, “nodeType”, “childNodes”, “firstChild”, “lastChild”, “previousSibling”, “attributes”, “ownerDocument”, “insertBefore”, “replaceChild”, “removeChild”, “hasChildNodes”, “cloneNode”, “normalize”, “isSupported”, “namespaceURI”, “prefix”, “localName”, “hasAttributes”, “getAttribute”, “setAttribute”, “removeAttribute”, “getAttributeNode”, “setAttributeNode”, “removeAttributeNode”, “getAttributeNS”, “setAttributeNS”, “removeAttributeNS”, “getAttributeNodeNS”, “setAttributeNodeNS”, “getElementsByTagNameNS”, “hasAttribute”, “hasAttributeNS”, “ELEMENT_NODE”, “ATTRIBUTE_NODE”, “TEXT_NODE”, “CDATA_SECTION_NODE”, “ENTITY_REFERENCE_NODE”, “ENTITY_NODE”, “PROCESSING_INSTRUCTION_NODE”, “COMMENT_NODE”, “DOCUMENT_NODE”, “DOCUMENT_TYPE_NODE”, “DOCUMENT_FRAGMENT_NODE”, “NOTATION_NODE”, “lang”, “dir”, “align”, “offsetTop”, “offsetLeft”, “offsetWidth”, “offsetHeight”, “offsetParent”, “scrollTop”, “scrollLeft”, “scrollHeight”, “scrollWidth”, “clientTop”, “clientLeft”, “clientHeight”, “clientWidth”, “tabIndex”, “contentEditable”, “blur”, “focus”, “spellcheck”, “removeEventListener”, “dispatchEvent”, “baseURI”, “compareDocumentPosition”, “textContent”, “isSameNode”, “lookupPrefix”, “isDefaultNamespace”, “lookupNamespaceURI”, “isEqualNode”, “getFeature”, “setUserData”, “getUserData”, “DOCUMENT_POSITION_DISCONNECTED”, “DOCUMENT_POSITION_PRECEDING”, “DOCUMENT_POSITION_FOLLOWING”, “DOCUMENT_POSITION_CONTAINS”, “DOCUMENT_POSITION_CONTAINED_BY”, “DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC”, “getElementsByClassName”, “getClientRects”, “getBoundingClientRect”]
870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 |
# File 'lib/vapir-firefox/jssh_socket.rb', line 870 def method_missing(method, *args) method=method.to_s if method =~ /\A([a-z_][a-z0-9_]*)([=?!])?\z/i method = $1 special = $2 else # don't deal with any special character crap #Object.instance_method(:method_missing).bind(self).call(method, *args) # let Object#method_missing raise its usual error return super end case special when nil invoke(method, *args) when '!' got=invoke(method, *args) got.is_a?(JsshObject) ? got.val : got when '?' begin got=invoke(method, *args) got.is_a?(JsshObject) ? got.val_str : got rescue JsshUndefinedValueError nil end when '=' attr(method).assign(*args) else Object.instance_method(:method_missing).bind(self).call(method, *args) # this shouldn't happen end end |
Instance Attribute Details
#debug_name ⇒ Object (readonly)
Returns the value of attribute debug_name.
555 556 557 |
# File 'lib/vapir-firefox/jssh_socket.rb', line 555 def debug_name @debug_name end |
#function_result ⇒ Object (readonly)
Returns the value of attribute function_result.
555 556 557 |
# File 'lib/vapir-firefox/jssh_socket.rb', line 555 def function_result @function_result end |
#jssh_socket ⇒ Object (readonly)
Returns the value of attribute jssh_socket.
554 555 556 |
# File 'lib/vapir-firefox/jssh_socket.rb', line 554 def jssh_socket @jssh_socket end |
#ref ⇒ Object (readonly)
Returns the value of attribute ref.
554 555 556 |
# File 'lib/vapir-firefox/jssh_socket.rb', line 554 def ref @ref end |
#type ⇒ Object (readonly)
returns javascript typeof this object
591 592 593 |
# File 'lib/vapir-firefox/jssh_socket.rb', line 591 def type @type end |
Instance Method Details
#%(operand) ⇒ Object
793 794 795 |
# File 'lib/vapir-firefox/jssh_socket.rb', line 793 def %(operand) binary_operator('%', operand) end |
#*(operand) ⇒ Object
790 791 792 |
# File 'lib/vapir-firefox/jssh_socket.rb', line 790 def *(operand) binary_operator('*', operand) end |
#+(operand) ⇒ Object
781 782 783 |
# File 'lib/vapir-firefox/jssh_socket.rb', line 781 def +(operand) binary_operator('+', operand) end |
#-(operand) ⇒ Object
784 785 786 |
# File 'lib/vapir-firefox/jssh_socket.rb', line 784 def -(operand) binary_operator('-', operand) end |
#/(operand) ⇒ Object
787 788 789 |
# File 'lib/vapir-firefox/jssh_socket.rb', line 787 def /(operand) binary_operator('/', operand) end |
#<(operand) ⇒ Object
802 803 804 |
# File 'lib/vapir-firefox/jssh_socket.rb', line 802 def <(operand) binary_operator('<', operand) end |
#<=(operand) ⇒ Object
808 809 810 |
# File 'lib/vapir-firefox/jssh_socket.rb', line 808 def <=(operand) binary_operator('<=', operand) end |
#==(operand) ⇒ Object
796 797 798 |
# File 'lib/vapir-firefox/jssh_socket.rb', line 796 def ==(operand) operand.is_a?(JsshObject) && binary_operator('==', operand) end |
#>(operand) ⇒ Object
799 800 801 |
# File 'lib/vapir-firefox/jssh_socket.rb', line 799 def >(operand) binary_operator('>', operand) end |
#>=(operand) ⇒ Object
805 806 807 |
# File 'lib/vapir-firefox/jssh_socket.rb', line 805 def >=(operand) binary_operator('>=', operand) end |
#[](key) ⇒ Object
returns a JsshObject referring to a subscript of this object, or a value if it is simple (see #val_or_object) subscript is specified as ruby (converted to_jssh).
768 769 770 |
# File 'lib/vapir-firefox/jssh_socket.rb', line 768 def [](key) sub(key).val_or_object(:error_on_undefined => false) end |
#[]=(key, value) ⇒ Object
assigns the given ruby value (passed through json via JsshSocket#assign_json) to the given subscript (key is converted to_jssh).
773 774 775 |
# File 'lib/vapir-firefox/jssh_socket.rb', line 773 def []=(key, value) self.sub(key).assign(value) end |
#assign(val) ⇒ Object
assigns (via JsshSocket#assign) the given ruby value (converted to_jssh) to the reference for this object. returns self.
683 684 685 686 687 688 |
# File 'lib/vapir-firefox/jssh_socket.rb', line 683 def assign(val) @debug_name="(#{debug_name}=#{val.is_a?(JsshObject) ? val.debug_name : val.to_jssh})" result=assign_expr val.to_jssh # logger.info { "#{self.class} assigned: #{debug_name} (type #{type})" } result end |
#assign_expr(val) ⇒ Object
assigns the given javascript expression (string) to the reference for this object
690 691 692 693 694 695 696 697 698 |
# File 'lib/vapir-firefox/jssh_socket.rb', line 690 def assign_expr(val) jssh_socket.value_json("(function(val){#{ref}=val; return null;}(#{val}))") @type=nil # uncache this # don't want to use JsshSocket#assign_json because converting the result of the assignment (that is, the expression assigned) to json is error-prone and we don't really care about the result. # don't want to use JsshSocket#assign because the result can be blank and cause send_and_read to wait for data that's not coming - also # using a json function is better because it catches errors much more elegantly. # so, wrap it in a function that returns nil. self end |
#attr(attribute) ⇒ Object
returns a JsshObject referencing the given attribute of this object
674 675 676 677 678 679 |
# File 'lib/vapir-firefox/jssh_socket.rb', line 674 def attr(attribute) unless (attribute.is_a?(String) || attribute.is_a?(Symbol)) && attribute.to_s =~ /\A[a-z_][a-z0-9_]*\z/i raise JsshSyntaxError, "#{attribute.inspect} (#{attribute.class.inspect}) is not a valid attribute!" end JsshObject.new("#{ref}.#{attribute}", jssh_socket, :debug_name => "#{debug_name}.#{attribute}") end |
#binary_operator(operator, operand) ⇒ Object
calls a binary operator with self and another operand
778 779 780 |
# File 'lib/vapir-firefox/jssh_socket.rb', line 778 def binary_operator(operator, operand) JsshObject.new("(#{ref}#{operator}#{operand.to_jssh})", jssh_socket, :debug_name => "(#{debug_name}#{operator}#{operand.is_a?(JsshObject) ? operand.debug_name : operand.to_jssh})").val_or_object end |
#call(*args) ⇒ Object
returns the value (via JsshSocket#value_json) or a JsshObject (see #val_or_object) of the return value of this function (assumes this object is a function) passing it the given arguments (which are converted to_jssh). simply, it just calls self.pass(*args).val_or_object
710 711 712 |
# File 'lib/vapir-firefox/jssh_socket.rb', line 710 def call(*args) pass(*args).val_or_object end |
#define_methods! ⇒ Object
898 899 900 901 902 903 904 905 |
# File 'lib/vapir-firefox/jssh_socket.rb', line 898 def define_methods! =(class << self; self; end) self.to_hash.keys.grep(/\A[a-z_][a-z0-9_]*\z/i).reject{|k| self.class.method_defined?(k)}.each do |key| .send(:define_method, key) do |*args| invoke(key, *args) end end end |
#id(*args) ⇒ Object
933 934 935 |
# File 'lib/vapir-firefox/jssh_socket.rb', line 933 def id(*args) invoke :id, *args end |
#implemented_interfaces ⇒ Object
609 610 611 612 613 614 |
# File 'lib/vapir-firefox/jssh_socket.rb', line 609 def implemented_interfaces jssh_socket.Components.interfaces.to_hash.inject([]) do |list, (key, interface)| list << interface if instanceof(interface) list end end |
#inspect ⇒ Object
992 993 994 |
# File 'lib/vapir-firefox/jssh_socket.rb', line 992 def inspect "\#<#{self.class.name}:0x#{"%.8x"%(self.hash*2)} #{[:type, :debug_name].map{|attr| attr.to_s+'='+send(attr).to_s}.join(', ')}>" end |
#instanceof(interface) ⇒ Object
returns javascript instanceof operator on this and the given interface (expected to be a JsshObject) note that this is javascript, not to be confused with ruby’s #instance_of? method.
example: window.instanceof(window.jssh_socket.Components.interfaces.nsIDOMChromeWindow)
> true
606 607 608 |
# File 'lib/vapir-firefox/jssh_socket.rb', line 606 def instanceof(interface) jssh_socket.instanceof(self.ref, interface.ref) end |
#invoke(attribute, *args) ⇒ Object
returns a JsshObject representing the given attribute. Checks the type, and if it is a function, references the _return value_ of the function (with the given arguments, if any, which are in ruby, converted to_jssh). If the type of the expression is undefined, raises an error (if you want an attribute even if it’s undefined, use #attr).
658 659 660 661 662 663 664 665 666 667 668 669 670 671 |
# File 'lib/vapir-firefox/jssh_socket.rb', line 658 def invoke(attribute, *args) attr_obj=attr(attribute) type=attr_obj.type case type when 'function' attr_obj.call(*args) else if args.empty? attr_obj.val_or_object else raise ArgumentError, "Cannot pass arguments to expression #{attr_obj.ref} of type #{type}" end end end |
#object_respond_to?(method) ⇒ Boolean
910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 |
# File 'lib/vapir-firefox/jssh_socket.rb', line 910 def object_respond_to?(method) method=method.to_s if method =~ /^([a-z_][a-z0-9_]*)([=?!])?$/i method = $1 special = $2 else # don't deal with any special character crap return false end if self.type=='undefined' return false elsif special=='=' if self.type=='object' return true # yeah, you can generally assign attributes to objects else return false # no, you can't generally assign attributes to (boolean, number, string, null) end else attr=attr(method) return attr.type!='undefined' end end |
#object_type ⇒ Object
returns the type of object that is reported by the javascript toString() method, which returns such as “[object Object]” or “[object XPCNativeWrapper [object HTMLDocument]]” This method returns ‘Object’ or ‘XPCNativeWrapper [object HTMLDocument]’ respectively. Raises an error if this JsshObject points to something other than a javascript ‘object’ type (‘function’ or ‘number’ or whatever)
621 622 623 624 625 626 627 628 629 630 631 |
# File 'lib/vapir-firefox/jssh_socket.rb', line 621 def object_type @object_type ||= begin case type when 'object' self.toString! =~ /\A\[object\s+(.*)\]\Z/ $1 else raise JsshError, "Type is #{type}, not object" end end end |
#pass(*args) ⇒ Object
returns a JsshObject for this object - assumes that this object is a function - passing this function the specified arguments, which are converted to_jssh
702 703 704 |
# File 'lib/vapir-firefox/jssh_socket.rb', line 702 def pass(*args) JsshObject.new("#{ref}(#{args.map{|arg| arg.to_jssh}.join(', ')})", jssh_socket, :function_result => true, :debug_name => "#{debug_name}(#{args.map{|arg| arg.is_a?(JsshObject) ? arg.debug_name : arg.to_jssh}.join(', ')})") end |
#pretty_print(pp) ⇒ Object
995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 |
# File 'lib/vapir-firefox/jssh_socket.rb', line 995 def pretty_print(pp) pp.object_address_group(self) do pp.seplist([:type, :debug_name], lambda { pp.text ',' }) do |attr| pp.breakable ' ' pp.group(0) do pp.text attr.to_s pp.text ': ' #pp.breakable pp.text send(attr) end end end end |
#respond_to?(method) ⇒ Boolean
907 908 909 |
# File 'lib/vapir-firefox/jssh_socket.rb', line 907 def respond_to?(method) super || object_respond_to?(method) end |
#store(js_variable, somewhere_meaningful = true) ⇒ Object
sets the given javascript variable to this object, and returns a JsshObject referring to the variable.
>> foo=document.getElementById(‘guser’).store(‘foo’)
> #<JsshObject:0x2dff870 @ref=“foo” …>
>> foo.tagName
> “DIV”
721 722 723 724 725 |
# File 'lib/vapir-firefox/jssh_socket.rb', line 721 def store(js_variable, somewhere_meaningful=true) stored=JsshObject.new(js_variable, jssh_socket, :function_result => false, :debug_name => somewhere_meaningful ? "(#{js_variable}=#{debug_name})" : debug_name) stored.assign_expr(self.ref) stored end |
#store_rand_named(&name_proc) ⇒ Object
727 728 729 730 731 732 733 734 735 |
# File 'lib/vapir-firefox/jssh_socket.rb', line 727 def store_rand_named(&name_proc) base=36 length=6 begin name=name_proc.call(("%#{length}s"%rand(base**length).to_s(base)).tr(' ','0')) end while JsshObject.new(name,jssh_socket).type!='undefined' # okay, more than one iteration is ridiculously unlikely, sure, but just to be safe. store(name, false) end |
#store_rand_object_key(object) ⇒ Object
743 744 745 746 747 748 |
# File 'lib/vapir-firefox/jssh_socket.rb', line 743 def store_rand_object_key(object) raise ArgumentError("Object is not a JsshObject: got #{object.inspect}") unless object.is_a?(JsshObject) store_rand_named do |r| object.sub(r).ref end end |
#store_rand_prefix(prefix) ⇒ Object
737 738 739 740 741 |
# File 'lib/vapir-firefox/jssh_socket.rb', line 737 def store_rand_prefix(prefix) store_rand_named do |r| prefix+"_"+r end end |
#store_rand_temp ⇒ Object
750 751 752 |
# File 'lib/vapir-firefox/jssh_socket.rb', line 750 def store_rand_temp store_rand_object_key(jssh_socket.temp_object) end |
#sub(key) ⇒ Object
returns a JsshObject referring to a subscript of this object, specified as a ruby object converted to javascript via to_jssh
762 763 764 |
# File 'lib/vapir-firefox/jssh_socket.rb', line 762 def sub(key) JsshObject.new("#{ref}[#{key.to_jssh}]", jssh_socket, :debug_name => "#{debug_name}[#{key.is_a?(JsshObject) ? key.debug_name : key.to_jssh}]") end |
#to_array ⇒ Object
958 959 960 |
# File 'lib/vapir-firefox/jssh_socket.rb', line 958 def to_array JsshArray.new(self.ref, self.jssh_socket, :debug_name => debug_name) end |
#to_dom ⇒ Object
964 965 966 |
# File 'lib/vapir-firefox/jssh_socket.rb', line 964 def to_dom JsshDOMNode.new(self.ref, self.jssh_socket, :debug_name => debug_name) end |
#to_hash ⇒ Object
961 962 963 |
# File 'lib/vapir-firefox/jssh_socket.rb', line 961 def to_hash JsshHash.new(self.ref, self.jssh_socket, :debug_name => debug_name) end |
#to_js_array ⇒ Object
949 950 951 |
# File 'lib/vapir-firefox/jssh_socket.rb', line 949 def to_js_array jssh_socket.object('$A').call(self) end |
#to_js_hash ⇒ Object
952 953 954 |
# File 'lib/vapir-firefox/jssh_socket.rb', line 952 def to_js_hash jssh_socket.object('$H').call(self) end |
#to_js_hash_safe ⇒ Object
955 956 957 |
# File 'lib/vapir-firefox/jssh_socket.rb', line 955 def to_js_hash_safe jssh_socket.object('$_H').call(self) end |
#to_json(options = {}) ⇒ Object
this still needs to be defined because when ActiveSupport::JSON.encode is called by to_jssh on an array or hash containing a JsshObject, it calls to_json. which apparently just freezes. I guess that’s because JsshSocket circularly references itself with its instance variables.
945 946 947 |
# File 'lib/vapir-firefox/jssh_socket.rb', line 945 def to_json(={}) ref end |
#to_jssh ⇒ Object
gives a reference for this object. this is the only class for which to_jssh doesn’t convert the object to json.
939 940 941 |
# File 'lib/vapir-firefox/jssh_socket.rb', line 939 def to_jssh ref end |
#to_ruby_hash(options = {}) ⇒ Object
967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 |
# File 'lib/vapir-firefox/jssh_socket.rb', line 967 def to_ruby_hash(={}) ={:recurse => 1}.merge() return self if ![:recurse] || [:recurse]==0 return self if self.type!='object' =.merge(:recurse => [:recurse]-1) begin keys=self.to_hash.keys rescue JsshError return self end keys.inject({}) do |hash, key| val=begin self[key] rescue JsshError $! end hash[key]=if val.is_a?(JsshObject) val.to_ruby_hash() else val end hash end end |
#val ⇒ Object
returns the value, via JsshSocket#value_json
576 577 578 |
# File 'lib/vapir-firefox/jssh_socket.rb', line 576 def val jssh_socket.value_json(ref, :error_on_undefined => !function_result) end |
#val_or_object(options = {}) ⇒ Object
633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 |
# File 'lib/vapir-firefox/jssh_socket.rb', line 633 def val_or_object(={}) ={:error_on_undefined=>true}.merge() if function_result # calling functions multiple times is bad, so store in temp before figuring out what to do with it store_rand_object_key(jssh_socket.temp_object).val_or_object(:error_on_undefined => false) else case self.type when 'undefined' if ![:error_on_undefined] nil else raise JsshUndefinedValueError, "undefined expression #{ref}" end when 'boolean','number','string','null' val else # 'function','object', or anything else self end end end |
#val_str ⇒ Object
returns the value just as a string with no attempt to deal with type using json. via JsshSocket#value
note that this can be slow if it evaluates to a blank string. for example, if ref is just “” then JsshSocket#value will wait DEFAULT_SOCKET_TIMEOUT seconds for data that is not to come. this also happens with functions that return undefined. if ref=“function()do_some_stuff;” (with no return), it will also wait DEFAULT_SOCKET_TIMEOUT.
586 587 588 |
# File 'lib/vapir-firefox/jssh_socket.rb', line 586 def val_str jssh_socket.value(ref) end |