idx int64 0 24.9k | question stringlengths 68 4.14k | target stringlengths 9 749 |
|---|---|---|
5,400 | def filename_from_content_disposition ( content_disposition ) content_disposition = content_disposition . to_s escaped_filename = content_disposition [ / \* \S / , 1 ] || content_disposition [ / / , 1 ] || content_disposition [ / \S / , 1 ] filename = CGI . unescape ( escaped_filename . to_s ) filename unless filename ... | Retrieves potential filename from the Content - Disposition header . |
5,401 | def download ( url , * args , max_size : nil , content_length_proc : nil , progress_proc : nil , destination : nil , ** options ) io = open ( url , * args , ** options , rewindable : false ) content_length_proc . call ( io . size ) if content_length_proc && io . size if max_size && io . size && io . size > max_size rai... | Initializes the backend with common defaults . Downlods the remote file to disk . Accepts wget command - line options and some additional options as well . |
5,402 | def open ( url , * args , rewindable : true , ** options ) arguments = generate_command ( url , * args , ** options ) command = Down :: Wget :: Command . execute ( arguments ) output = Down :: ChunkedIO . new ( chunks : command . enum_for ( :output ) , on_close : command . method ( :terminate ) , rewindable : false , )... | Starts retrieving the remote file and returns an IO - like object which downloads the response body on - demand . Accepts wget command - line options . |
5,403 | def generate_command ( url , * args , ** options ) command = %W[ wget --no-verbose --save-headers -O - ] options = @arguments . grep ( Hash ) . inject ( { } , :merge ) . merge ( options ) args = @arguments . grep ( -> ( o ) { ! o . is_a? ( Hash ) } ) + args ( args + options . to_a ) . each do | option , value | if opti... | Generates the wget command . |
5,404 | def download ( url , max_size : nil , progress_proc : nil , content_length_proc : nil , destination : nil , ** options , & block ) response = request ( url , ** options , & block ) content_length_proc . call ( response . content_length ) if content_length_proc && response . content_length if max_size && response . cont... | Initializes the backend with common defaults . Downlods the remote file to disk . Accepts HTTP . rb options via a hash or a block and some additional options as well . |
5,405 | def open ( url , rewindable : true , ** options , & block ) response = request ( url , ** options , & block ) Down :: ChunkedIO . new ( chunks : enum_for ( :stream_body , response ) , size : response . content_length , encoding : response . content_type . charset , rewindable : rewindable , data : { status : response .... | Starts retrieving the remote file and returns an IO - like object which downloads the response body on - demand . Accepts HTTP . rb options via a hash or a block . |
5,406 | def stream_body ( response , & block ) response . body . each ( & block ) rescue => exception request_error! ( exception ) ensure response . connection . close unless @client . persistent? end | Yields chunks of the response body to the block . |
5,407 | def download ( url , options = { } ) options = @options . merge ( options ) max_size = options . delete ( :max_size ) max_redirects = options . delete ( :max_redirects ) progress_proc = options . delete ( :progress_proc ) content_length_proc = options . delete ( :content_length_proc ) destination = options . delete ( :... | Initializes the backend with common defaults . Downloads a remote file to disk using open - uri . Accepts any open - uri options and a few more . |
5,408 | def ensure_uri ( url , allow_relative : false ) begin uri = URI ( url ) rescue URI :: InvalidURIError => exception raise Down :: InvalidUrl , exception . message end unless allow_relative && uri . relative? raise Down :: InvalidUrl , "URL scheme needs to be http or https: #{uri}" unless uri . is_a? ( URI :: HTTP ) end ... | Checks that the url is a valid URI and that its scheme is http or https . |
5,409 | def addressable_normalize ( url ) addressable_uri = Addressable :: URI . parse ( url ) addressable_uri . normalize . to_s end | Makes sure that the URL is properly encoded . |
5,410 | def download_result ( tempfile , destination ) return tempfile unless destination tempfile . close FileUtils . mv tempfile . path , destination nil end | If destination path is defined move tempfile to the destination otherwise return the tempfile unchanged . |
5,411 | def xirr guess , options func = Function . new ( self , :xnpv ) rate = [ guess || cf . irr_guess ] begin nlsolve ( func , rate ) ( rate [ 0 ] <= - 1 || rate [ 0 ] . nan? ) ? nil : rate [ 0 ] . round ( Xirr :: PRECISION ) rescue nil end end | Calculates XIRR using Newton method |
5,412 | def xirr ( midpoint , options ) left = [ BigDecimal . new ( - 0.99999999 , Xirr :: PRECISION ) , cf . irr_guess ] . min right = [ BigDecimal . new ( 9.99999999 , Xirr :: PRECISION ) , cf . irr_guess + 1 ] . max @original_right = right midpoint ||= cf . irr_guess midpoint , runs = loop_rates ( left , midpoint , right , ... | Calculates yearly Internal Rate of Return |
5,413 | def xnpv ( rate ) cf . inject ( 0 ) do | sum , t | sum + ( xnpv_c rate , t . amount , periods_from_start ( t . date ) ) end end | Net Present Value function that will be used to reduce the cashflow |
5,414 | def define_staging_file_tasks ( files , lib_path , stage_path , platf , ruby_ver ) files . each do | gem_file | next if File . directory? ( gem_file ) || gem_file == "#{lib_path}/#{binary(platf)}" stage_file = "#{stage_path}/#{gem_file}" unless Rake :: Task . task_defined? ( stage_file ) then directory File . dirname (... | copy other gem files to staging directory |
5,415 | def java_extdirs_arg extdirs = Java :: java . lang . System . getProperty ( 'java.ext.dirs' ) rescue nil extdirs = ENV [ 'JAVA_EXT_DIR' ] unless extdirs java_extdir = extdirs . nil? ? "" : "-extdirs \"#{extdirs}\"" end | Discover Java Extension Directories and build an extdirs argument |
5,416 | def shell ( shell_type , shell_opts = { } ) shell = shell_factory . create_shell ( shell_type , shell_opts ) if block_given? begin yield shell ensure shell . close end else shell end end | Creates a new shell on the remote Windows server associated with this connection . |
5,417 | def run_wql ( wql , namespace = 'root/cimv2/*' , & block ) query = WinRM :: WSMV :: WqlQuery . new ( transport , @connection_opts , wql , namespace ) query . process_response ( transport . send_request ( query . build ) , & block ) end | Executes a WQL query against the WinRM connection |
5,418 | def includes_token? ( obj , value ) return false unless obj . kind_of? ( Array ) obj . map ( & :to_sym ) . include? ( value . to_sym ) end | Takes an Array and a value and returns true if the value exists in the array in String or Symbol form otherwise false . |
5,419 | def ignore_by_class? ( ignored_class = nil ) @ignore_by_class ||= Proc . new do | ignored_class | case error_class when ( ignored_class . respond_to? ( :name ) ? ignored_class . name : ignored_class ) true else exception && ignored_class . is_a? ( Class ) && exception . class < ignored_class end end ignored_class ? @ig... | Determines if error class should be ignored . |
5,420 | def construct_request_hash request = { url : url , component : component , action : action , params : params , session : session , cgi_data : cgi_data , sanitizer : request_sanitizer } request . delete_if { | k , v | config . excluded_request_keys . include? ( k ) } Util :: RequestPayload . build ( request ) end | Construct the request data . |
5,421 | def exception_context ( exception ) object = exception if exception . respond_to? ( :to_honeybadger_context ) object ||= { } . freeze Context ( object ) end | Get optional context from exception . |
5,422 | def parse_backtrace ( backtrace ) Backtrace . parse ( backtrace , filters : construct_backtrace_filters ( opts ) , config : config , source_radius : config [ :' ' ] ) . to_a end | Parse Backtrace from exception backtrace . |
5,423 | def exception_cause ( exception ) e = exception if e . respond_to? ( :cause ) && e . cause && e . cause . is_a? ( Exception ) e . cause elsif e . respond_to? ( :original_exception ) && e . original_exception && e . original_exception . is_a? ( Exception ) e . original_exception elsif e . respond_to? ( :continued_except... | Fetch cause from exception . |
5,424 | def unwrap_causes ( cause ) causes , c , i = [ ] , cause , 0 while c && i < MAX_EXCEPTION_CAUSES causes << { class : c . class . name , message : c . message , backtrace : parse_backtrace ( c . backtrace || caller ) } i += 1 c = exception_cause ( c ) end causes end | Create a list of causes . |
5,425 | def flush mutex . synchronize do if thread && thread . alive? queue . push ( marker ) marker . wait ( mutex ) end end end | Blocks until queue is processed up to this point in time . |
5,426 | def notify ( exception_or_opts , opts = { } ) if exception_or_opts . is_a? ( Exception ) opts [ :exception ] = exception_or_opts elsif exception_or_opts . respond_to? ( :to_hash ) opts . merge! ( exception_or_opts . to_hash ) else opts [ :error_message ] = exception_or_opts . to_s end validate_notify_opts! ( opts ) opt... | Sends an exception to Honeybadger . Does not report ignored exceptions by default . |
5,427 | def check_in ( id ) check_in_id = id . to_s . strip . gsub ( / \/ / , '' ) . split ( '/' ) . last response = backend . check_in ( check_in_id ) response . success? end | Perform a synchronous check_in . |
5,428 | def to_ary lines . take ( 1000 ) . map { | l | { :number => l . filtered_number , :file => l . filtered_file , :method => l . filtered_method , :source => l . source } } end | Convert Backtrace to arry . |
5,429 | def keys_to_keep ( operation ) o = @sdk . operations [ operation ] begin say_error "Operation #{operation} not found" return [ ] end unless o parameters = o [ :info ] [ :parameters ] . select { | p | p [ :in ] == "body" && p [ :schema ] } say_warning "Expecting exactly one body parameter with a schema for operation #{o... | This method accepts the name of an sdk operation then finds the parameter for that operation in the data structures from the swagger . json file . The parameter is a json object . Some of the attributes of the json object are read - only and some are read - write . A few are write - only . The list of read - write and ... |
5,430 | def render_csv ( t ) io = StringIO . new io . puts ( t . header . collect do | v | v ? "\"#{v.to_s.gsub(/"/, '""')}\"" : "" end . join ( ',' ) ) unless @options [ :plain ] t . each do | row | next if row === t . header io . puts ( row . collect do | v | v ? "\"#{v.to_s.gsub(/"/, '""')}\"" : "" end . join ( ',' ) ) end ... | The tty - table gem is normally used to output tabular data . This method accepts a Table object as used by the tty - table gem and generates CSV output . It returns a string with crlf encoding |
5,431 | def field_names ( opt_fields ) fields = [ ] token_stack = [ ] last_token = false tokens = opt_fields . split / \( \) / tokens << nil tokens . each do | t | if t . nil? then fields << ( token_stack + [ last_token ] ) . join ( '.' ) if last_token elsif t . empty? then next elsif t == ',' then fields << ( token_stack + [ ... | This method accepts a string containing a list of fields . The fields can be nested in a format like ... |
5,432 | def oclcnum ( extract_fields = "035a" ) extractor = MarcExtractor . new ( extract_fields , :separator => nil ) lambda do | record , accumulator | list = extractor . extract ( record ) . collect! do | o | Marc21Semantics . oclcnum_extract ( o ) end . compact accumulator . concat list . uniq if list end end | Extract OCLC numbers from by default 035a s by known prefixes then stripped just the num and de - dup . |
5,433 | def marc_sortable_title lambda do | record , accumulator | st = Marc21Semantics . get_sortable_title ( record ) accumulator << st if st end end | 245 a and b with non - filing characters stripped off |
5,434 | def marc_publication_date ( options = { } ) estimate_tolerance = options [ :estimate_tolerance ] || 15 min_year = options [ :min_year ] || 500 max_year = options [ :max_year ] || ( Time . new . year + 6 ) lambda do | record , accumulator | date = Marc21Semantics . publication_date ( record , estimate_tolerance , min_ye... | An opinionated algorithm for getting a SINGLE publication date out of marc |
5,435 | def marc_geo_facet ( options = { } ) marc_geo_map = Traject :: TranslationMap . new ( "marc_geographic" ) a_fields_spec = options [ :geo_a_fields ] || "651a:691a" z_fields_spec = options [ :geo_z_fields ] || "600:610:611:630:648:650:654:655:656:690:651:691" extractor_043a = MarcExtractor . new ( "043a" , :separator => ... | An opinionated method of making a geographic facet out of BOTH 048 marc codes AND geo subdivisions in 6xx LCSH subjects . |
5,436 | def marc_lcsh_formatted ( options = { } ) spec = options [ :spec ] || "600:610:611:630:648:650:651:654:662" subd_separator = options [ :subdivison_separator ] || " — " other_separator = options [ :other_separator ] || " " extractor = MarcExtractor . new ( spec ) return lambda do | record , accumulator | accumulator . c... | Extracts LCSH - carrying fields and formatting them as a pre - coordinated LCSH string for instance suitable for including in a facet . |
5,437 | def translate_array ( array ) array . each_with_object ( [ ] ) do | input_element , output_array | output_element = self . map ( input_element ) if output_element . kind_of? Array output_array . concat output_element elsif ! output_element . nil? output_array << output_element end end end | Run every element of an array through this translation map return the resulting array . If translation map returns nil original element will be missing from output . |
5,438 | def merge ( other_map ) default = other_map . default || self . default TranslationMap . new ( self . to_hash . merge ( other_map . to_hash ) , :default => default ) end | Return a new TranslationMap that results from merging argument on top of self . Can be useful for taking an existing translation map but merging a few overrides on top . |
5,439 | def extract_all_marc_values ( options = { } ) unless ( options . keys - EXTRACT_ALL_MARC_VALID_OPTIONS ) . empty? raise RuntimeError . new ( "Illegal/Unknown argument '#{(options.keys - EXTRACT_ALL_MARC_VALID_OPTIONS).join(', ')}' in extract_all_marc at #{Traject::Util.extract_caller_location(caller.first)}" ) end opti... | Takes the whole record by default from tags 100 to 899 inclusive all subfields and adds them to output . Subfields in a record are all joined by space by default . |
5,440 | def http_client @http_client ||= begin client = HTTP . timeout ( :global , write : timeout / 3 , connect : timeout / 3 , read : timeout / 3 ) if settings [ "oai_pmh.try_gzip" ] client = client . use ( :auto_inflate ) . headers ( "accept-encoding" => "gzip;q=1.0, identity;q=0.5" ) end if settings [ "oai_pmh.http_persist... | re - use an http - client for subsequent requests to get http . rb s persistent connection re - use Note this means this is NOT thread safe which is fine for now but we d have to do something different if we tried to multi - thread reading multiple files or something . |
5,441 | def _transform_columns ( component , inner ) col_count = component . parent . elements . size small_val = component . attr ( 'small' ) large_val = component . attr ( 'large' ) small_size = small_val || column_count large_size = large_val || small_val || ( column_count / col_count ) . to_i classes = _combine_classes ( c... | in inky . js this is factored out into makeClumn . TBD if we need that here . |
5,442 | def index @index ||= begin idx = @wiki . repo . index if ( tree = options [ :tree ] ) idx . read_tree ( tree ) elsif ( parent = parents . first ) idx . read_tree ( parent . tree . id ) end idx end end | Initializes the Committer . |
5,443 | def add_to_index ( dir , name , format , data , allow_same_ext = false ) dir . gsub! ( ' ' , '-' ) name . gsub! ( ' ' , '-' ) path = @wiki . page_file_name ( name , format ) dir = '/' if dir . strip . empty? fullpath = :: File . join ( * [ dir , path ] ) fullpath = fullpath [ 1 .. - 1 ] if fullpath =~ / \/ / if index .... | Adds a page to the given Index . |
5,444 | def commit sha1 = index . commit ( @options [ :message ] , parents , actor , nil , @wiki . ref ) @callbacks . each do | cb | cb . call ( self , sha1 ) end sha1 end | Writes the commit to Git and runs the after_commit callbacks . |
5,445 | def file_path_scheduled_for_deletion? ( map , path ) parts = path . split ( '/' ) if parts . size == 1 deletions = map . keys . select { | k | ! map [ k ] } deletions . any? { | d | d == parts . first } else part = parts . shift if ( rest = map [ part ] ) file_path_scheduled_for_deletion? ( rest , parts . join ( '/' ) ... | Determine if a given file is scheduled to be deleted in the next commit for the given Index . |
5,446 | def method_missing ( name , * args ) args . map! { | item | item . respond_to? ( :force_encoding ) ? item . force_encoding ( 'ascii-8bit' ) : item } index . send ( name , * args ) end | Proxies methods t |
5,447 | def find ( name , version , try_on_disk = false ) checked = name . downcase map = @wiki . tree_map_for ( version ) commit = version . is_a? ( Gollum :: Git :: Commit ) ? version : @wiki . commit_for ( version ) if ( result = map . detect { | entry | entry . path . downcase == checked } ) @path = name @version = commit ... | Find a file in the given Gollum repo . |
5,448 | def page ( wiki , commit ) blob = self . blob ( wiki . repo ) page = wiki . page_class . new ( wiki ) . populate ( blob , self . dir ) page . version = commit page end | Gets a Page instance for this blob . |
5,449 | def file ( wiki , commit ) blob = self . blob ( wiki . repo ) file = wiki . file_class . new ( wiki ) . populate ( blob , self . dir ) file . version = commit file end | Gets a File instance for this blob . |
5,450 | def render_default ( data , format = :markdown , name = 'render_default.md' ) @format = format @name = name chain = [ :Metadata , :PlainText , :Emoji , :TOC , :RemoteCode , :Code , :Sanitize , :WSD , :Tags , :Render ] filter_chain = chain . map do | r | Gollum :: Filter . const_get ( r ) . new ( self ) end process_chai... | Render data using default chain in the target format . |
5,451 | def process_chain ( data , filter_chain ) filter_chain . each do | filter | data = filter . extract ( data ) end filter_chain . reverse . each do | filter | data = filter . process ( data ) end data . gsub! ( / \/ / ) do '' end data end | Process the filter chain |
5,452 | def render ( no_follow = false , encoding = nil , include_levels = 10 ) @sanitize = no_follow ? @wiki . history_sanitizer : @wiki . sanitizer @encoding = encoding @include_levels = include_levels data = @data . dup filter_chain = @wiki . filter_chain . map do | r | Gollum :: Filter . const_get ( r ) . new ( self ) end ... | Render the content with Gollum wiki syntax on top of the file s own markup language . |
5,453 | def find_file ( name , version = @version ) if name =~ / \/ / @wiki . file ( name [ 1 .. - 1 ] , version ) else path = @dir == '.' ? name : :: File . join ( @dir , name ) @wiki . file ( path , version ) end end | Find the given file in the repo . |
5,454 | def remove_filter ( name ) unless name . is_a? Symbol raise ArgumentError , "Invalid filter name #{name.inspect} (must be a symbol)" end unless @filter_chain . delete ( name ) raise ArgumentError , "#{name.inspect} not found in filter chain" end end | Remove the named filter from the filter chain . |
5,455 | def tree_list ( ref ) if ( sha = @access . ref_to_sha ( ref ) ) commit = @access . commit ( sha ) tree_map_for ( sha ) . inject ( [ ] ) do | list , entry | next list unless @page_class . valid_page_name? ( entry . name ) list << entry . page ( self , commit ) end else [ ] end end | Fill an array with a list of pages . |
5,456 | def file_list ( ref ) if ( sha = @access . ref_to_sha ( ref ) ) commit = @access . commit ( sha ) tree_map_for ( sha ) . inject ( [ ] ) do | list , entry | next list if entry . name . start_with? ( '_' ) next list if @page_class . valid_page_name? ( entry . name ) list << entry . file ( self , commit ) end else [ ] end... | Fill an array with a list of files . |
5,457 | def tree_map_for ( ref , ignore_page_file_dir = false ) if ignore_page_file_dir && ! @page_file_dir . nil? @root_access ||= GitAccess . new ( path , nil , @repo_is_bare ) @root_access . tree ( ref ) else @access . tree ( ref ) end rescue Gollum :: Git :: NoSuchShaFound [ ] end | Finds a full listing of files and their blob SHA for a given ref . Each listing is cached based on its actual commit SHA . |
5,458 | def get_cache ( name , key ) cache = instance_variable_get ( "@#{name}_map" ) value = cache [ key ] if value . nil? && block_given? set_cache ( name , key , value = yield ) end value == :_nil ? nil : value end | Attempts to get the given data from a cache . If it doesn t exist it ll pass the results of the yielded block to the cache for future accesses . |
5,459 | def parse_tree_line ( line ) mode , _type , sha , size , * name = line . split ( / \s / ) BlobEntry . new ( sha , name . join ( ' ' ) , size . to_i , mode . to_i ( 8 ) ) end | Parses a line of output from the ls - tree command . |
5,460 | def find ( name , version , dir = nil , exact = false ) map = @wiki . tree_map_for ( version . to_s ) if ( page = find_page_in_tree ( map , name , dir , exact ) ) page . version = version . is_a? ( Gollum :: Git :: Commit ) ? version : @wiki . commit_for ( version ) page . historical = page . version . to_s == version ... | Find a page in the given Gollum repo . |
5,461 | def find_page_in_tree ( map , name , checked_dir = nil , exact = false ) return nil if ! map || name . to_s . empty? checked_dir = BlobEntry . normalize_dir ( checked_dir ) checked_dir = '' if exact && checked_dir . nil? name = :: File . join ( checked_dir , name ) if checked_dir map . each do | entry | next if entry .... | Find a page in a given tree . |
5,462 | def tree_path ( treemap , tree ) if ( ptree = treemap [ tree ] ) tree_path ( treemap , ptree ) + '/' + tree . name else '' end end | The full directory path for the given tree . |
5,463 | def page_match ( name , path ) if ( match = self . class . valid_filename? ( path ) ) @wiki . ws_subs . each do | sub | return true if Page . cname ( name ) . downcase == Page . cname ( match , sub ) . downcase end end false end | Compare the canonicalized versions of the two names . |
5,464 | def find_value ( user , object ) case object when Hash object . each . with_object ( { } ) do | ( key , value ) , hash | hash [ key ] = find_value ( user , value ) end when Array object . map do | value | find_value ( user , value ) end when Symbol user . public_send ( object ) else object end end | find_value is a recursive method that takes a user and a user schema and replaces any symbols in the schema with the corresponding value from the user . Given a schema with symbols find_value will search through the object for the symbols send those symbols to the model and replace the symbol with the return value . |
5,465 | def path_for ( attribute , object = ScimRails . config . mutable_user_attributes_schema , path = [ ] ) at_path = path . empty? ? object : object . dig ( * path ) return path if at_path == attribute case at_path when Hash at_path . each do | key , value | found_path = path_for ( attribute , object , [ * path , key ] ) r... | path_for is a recursive method used to find the path for . dig to take when looking for a given attribute in the params . |
5,466 | def send_envelope ( envelope_id ) content_type = { 'Content-Type' => 'application/json' } post_body = { status : 'sent' } . to_json uri = build_uri ( "/accounts/#{acct_id}/envelopes/#{envelope_id}" ) http = initialize_net_http_ssl ( uri ) request = Net :: HTTP :: Put . new ( uri . request_uri , headers ( content_type )... | Public marks an envelope as sent |
5,467 | def get_recipient_view ( options = { } ) content_type = { 'Content-Type' => 'application/json' } content_type . merge ( options [ :headers ] ) if options [ :headers ] post_body = { authenticationMethod : 'email' , clientUserId : options [ :client_id ] || options [ :email ] , email : options [ :email ] , returnUrl : opt... | Public returns the URL for embedded signing |
5,468 | def get_envelope_recipients ( options = { } ) content_type = { 'Content-Type' => 'application/json' } content_type . merge ( options [ :headers ] ) if options [ :headers ] include_tabs = options [ :include_tabs ] || false include_extended = options [ :include_extended ] || false uri = build_uri ( "/accounts/#{acct_id}/... | Public returns the envelope recipients for a given envelope |
5,469 | def get_page_image ( options = { } ) envelope_id = options [ :envelope_id ] document_id = options [ :document_id ] page_number = options [ :page_number ] uri = build_uri ( "/accounts/#{acct_id}/envelopes/#{envelope_id}/documents/#{document_id}/pages/#{page_number}/page_image" ) http = initialize_net_http_ssl ( uri ) re... | Public retrieves a png of a page of a document in an envelope |
5,470 | def get_document_from_envelope ( options = { } ) content_type = { 'Content-Type' => 'application/json' } content_type . merge ( options [ :headers ] ) if options [ :headers ] uri = build_uri ( "/accounts/#{acct_id}/envelopes/#{options[:envelope_id]}/documents/#{options[:document_id]}" ) http = initialize_net_http_ssl (... | Public retrieves the attached file from a given envelope |
5,471 | def delete_envelope_recipient ( options = { } ) content_type = { 'Content-Type' => 'application/json' } content_type . merge ( options [ :headers ] ) if options [ :headers ] uri = build_uri ( "/accounts/#{@acct_id}/envelopes/#{options[:envelope_id]}/recipients" ) post_body = "{ \"signers\" : [{\"recipientId\" : ... | Public deletes a recipient for a given envelope |
5,472 | def void_envelope ( options = { } ) content_type = { 'Content-Type' => 'application/json' } content_type . merge ( options [ :headers ] ) if options [ :headers ] post_body = { "status" => "voided" , "voidedReason" => options [ :voided_reason ] || "No reason provided." } . to_json uri = build_uri ( "/accounts/#{acct_id}... | Public voids an in - process envelope |
5,473 | def validate_uncles return false if Utils . keccak256_rlp ( uncles ) != uncles_hash return false if uncles . size > config [ :max_uncles ] uncles . each do | uncle | raise InvalidUncles , "Cannot find uncle prevhash in db" unless db . include? ( uncle . prevhash ) if uncle . number == number logger . error "uncle at sa... | Validate the uncles of this block . |
5,474 | def add_transaction_to_list ( tx ) k = RLP . encode @transaction_count @transactions [ k ] = RLP . encode ( tx ) r = mk_transaction_receipt tx @receipts [ k ] = RLP . encode ( r ) self . bloom |= r . bloom @transaction_count += 1 end | Add a transaction to the transaction trie . |
5,475 | def get_transaction ( num ) index = RLP . encode num tx = @transactions . get index raise IndexError , "Transaction does not exist" if tx == Trie :: BLANK_NODE RLP . decode tx , sedes : Transaction end | Get the num th transaction in this block . |
5,476 | def finalize delta = @config [ :block_reward ] + @config [ :nephew_reward ] * uncles . size delta_balance coinbase , delta self . ether_delta += delta uncles . each do | uncle | r = @config [ :block_reward ] * ( @config [ :uncle_depth_penalty_factor ] + uncle . number - number ) / @config [ :uncle_depth_penalty_factor ... | Apply rewards and commit . |
5,477 | def to_h ( with_state : false , full_transactions : false , with_storage_roots : false , with_uncles : false ) b = { header : header . to_h } txlist = [ ] get_transactions . each_with_index do | tx , i | receipt_rlp = @receipts [ RLP . encode ( i ) ] receipt = RLP . decode receipt_rlp , sedes : Receipt txjson = full_tr... | Serialize the block to a readable hash . |
5,478 | def get_parent raise UnknownParentError , "Genesis block has no parent" if number == 0 Block . find env , prevhash rescue KeyError raise UnknownParentError , Utils . encode_hex ( prevhash ) end | Get the parent of this block . |
5,479 | def chain_difficulty return difficulty if genesis? k = "difficulty:#{Utils.encode_hex(full_hash)}" return Utils . decode_int ( db . get ( k ) ) if db . has_key? ( k ) o = difficulty + get_parent . chain_difficulty @state . db . put_temporarily k , Utils . encode_int ( o ) o end | Get the summarized difficulty . |
5,480 | def account_is_empty ( address ) get_balance ( address ) == 0 && get_code ( address ) == Constant :: BYTE_EMPTY && get_nonce ( address ) == 0 end | Returns true when the account is either empty or non - exist . |
5,481 | def snapshot { state : @state . root_hash , gas : gas_used , txs : @transactions , txcount : @transaction_count , refunds : refunds , suicides : suicides , suicides_size : suicides . size , logs : logs , logs_size : logs . size , journal : @journal , journal_size : @journal . size , ether_delta : ether_delta } end | Make a snapshot of the current state to enable later reverting . |
5,482 | def revert ( mysnapshot ) logger . debug "REVERTING" @journal = mysnapshot [ :journal ] while @journal . size > mysnapshot [ :journal_size ] cache , index , prev , post = @journal . pop logger . debug "revert journal" , cache : cache , index : index , prev : prev , post : post if prev @caches [ cache ] [ index ] = prev... | Revert to a previously made snapshot . |
5,483 | def get_receipt ( num ) index = RLP . encode num receipt = @receipts [ index ] if receipt == Trie :: BLANK_NODE raise IndexError , "Receipt does not exist" else RLP . decode receipt , sedes : Receipt end end | Get the receipt of the num th transaction . |
5,484 | def get_receipts receipts = [ ] i = 0 loop do begin receipts . push get_receipt ( i ) i += 1 rescue IndexError return receipts end end end | Build a list of all receipts in this block . |
5,485 | def transfer_value ( from , to , value ) raise ArgumentError , "value must be greater or equal than zero" unless value >= 0 delta_balance ( from , - value ) && delta_balance ( to , value ) end | Transfer a value between two account balance . |
5,486 | def get_storage ( address ) storage_root = get_account_item address , :storage SecureTrie . new PruningTrie . new ( db , storage_root ) end | Get the trie holding an account s storage . |
5,487 | def get_storage_data ( address , index ) address = Utils . normalize_address address cache = @caches [ "storage:#{address}" ] return cache [ index ] if cache && cache . has_key? ( index ) key = Utils . zpad Utils . coerce_to_bytes ( index ) , 32 value = get_storage ( address ) [ key ] value . true? ? RLP . decode ( val... | Get a specific item in the storage of an account . |
5,488 | def set_storage_data ( address , index , value ) address = Utils . normalize_address address cache_key = "storage:#{address}" unless @caches . has_key? ( cache_key ) @caches [ cache_key ] = { } set_and_journal :all , address , true end set_and_journal cache_key , index , value end | Set a specific item in the storage of an account . |
5,489 | def account_to_dict ( address , with_storage_root : false , with_storage : true ) address = Utils . normalize_address address raise ArgumentError , "cannot include storage root with uncommited account changes" if with_storage_root && ! @journal . empty? h = { } account = get_account address h [ :nonce ] = ( @caches [ :... | Serialize an account to a hash with human readable entries . |
5,490 | def get_ancestor_list ( n ) raise ArgumentError , "n must be greater or equal than zero" unless n >= 0 return [ ] if n == 0 || number == 0 parent = get_parent [ parent ] + parent . get_ancestor_list ( n - 1 ) end | Return n ancestors of this block . |
5,491 | def validate_fields l = Block . serialize self RLP . decode ( RLP . encode ( l ) ) == l end | Check that the values of all fields are well formed . |
5,492 | def delta_account_item ( address , param , value ) new_value = get_account_item ( address , param ) + value return false if new_value < 0 set_account_item ( address , param , new_value % 2 ** 256 ) true end | Add a value to an account item . |
5,493 | def get_account_item ( address , param ) address = Utils . normalize_address address , allow_blank : true return @caches [ param ] [ address ] if @caches [ param ] . has_key? ( address ) account = get_account address v = account . send param @caches [ param ] [ address ] = v v end | Get a specific parameter of a specific account . |
5,494 | def set_account_item ( address , param , value ) raise ArgumentError , "invalid address: #{address}" unless address . size == 20 || address . size == 40 address = Utils . decode_hex ( address ) if address . size == 40 set_and_journal ( param , address , value ) set_and_journal ( :all , address , true ) end | Set a specific parameter of a specific account . |
5,495 | def get_account ( address ) address = Utils . normalize_address address , allow_blank : true rlpdata = @state [ address ] if rlpdata == Trie :: BLANK_NODE Account . build_blank db , config [ :account_initial_nonce ] else RLP . decode ( rlpdata , sedes : Account , db : db ) . tap do | acct | acct . make_mutable! acct . ... | Get the account with the given address . |
5,496 | def sign ( key ) raise InvalidTransaction , "Zero privkey cannot sign" if [ 0 , '' , Constant :: PRIVKEY_ZERO , Constant :: PRIVKEY_ZERO_HEX ] . include? ( key ) rawhash = Utils . keccak256 signing_data ( :sign ) key = PrivateKey . new ( key ) . encode ( :bin ) vrs = Secp256k1 . recoverable_sign rawhash , key self . v ... | Sign this transaction with a private key . |
5,497 | def creates Utils . mk_contract_address ( sender , nonce ) if [ Address :: BLANK , Address :: ZERO ] . include? ( to ) end | returns the address of a contract created by this tx |
5,498 | def mine ( rounds = 1000 , start_nonce = 0 ) blk = @block bin_nonce , mixhash = _mine ( blk . number , blk . difficulty , blk . mining_hash , start_nonce , rounds ) if bin_nonce . true? blk . mixhash = mixhash blk . nonce = bin_nonce return blk end end | Mines on the current head . Stores received transactions . |
5,499 | def root_hash return BLANK_ROOT if @root_node == BLANK_NODE raise InvalidNode , "invalid root node" unless @root_node . instance_of? ( Array ) val = FastRLP . encode @root_node key = Utils . keccak256 val @db . put key , val SPV . grabbing @root_node key end | It presents a hash like interface . |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.