Without [`respond_to_missing?`][1] defined, trying to get the method via [`method`][2] will fail:

    class Foo
      def method_missing name, *args
        p args
      end
    
      def respond_to? name, include_private = false
        true
      end
    end
    
    f = Foo.new
    f.bar  #=&gt; []
    f.respond_to? :bar  #=&gt; true
    f.method :bar  # NameError: undefined method `bar&#39; for class `Foo&#39;
    
    class Foo
      def respond_to? *args; super; end  # “Reverting” previous redefinition

      def respond_to_missing? *args
        true
      end
    end
    
    f.method :bar  #=&gt; #&lt;Method: Foo#bar&gt;

[Marc-Andr&#233;][3] (a Ruby core committer) has a good [blog post on `respond_to_missing?`][4].


  [1]: http://ruby-doc.org/core/Object.html#method-i-respond_to_missing-3F
  [2]: http://ruby-doc.org/core/Object.html#method-i-method
  [3]: https://stackoverflow.com/users/8279/marc-andre-lafortune
  [4]: http://blog.marc-andre.ca/2010/11/methodmissing-politely.html

It&#39;s a good practice to create **respond_to_missing?** if you are overriding **method_missing**. That way, the class will tell you the method you are calling exists, even though it&#39;s not explicitly declared.

respond_to? should probably not be overriden :)

I use Javascript code

    if( (Android|webOS|iPhone|iPad|iPod|BlackBerry).test(navigator.userAgent) ) {}

for mobile device detection, but Chrome at iOS is not detected. Is there a way to detect it?
Thanks. 


iOS Chrome detection

## Case 1

    class Program {
        static final int var;
    
        static {
            Program.var = 8;  // Compilation error
        }
    
        public static void main(String[] args) {
            int i;
            i = Program.var;
            System.out.println(Program.var);
        }
    }
    
## Case 2

    class Program {
        static final int var;
    
        static {
            var = 8;  //OK
        }
    
        public static void main(String[] args) {
            System.out.println(Program.var);
        }
    }

Why does **Case 1** cause a compilation error?

Why isn&#39;t a qualified static final variable allowed in a static initialization block?

What is the point of defining `respond_to_missing?` as opposed to defining `respond_to?`? What goes wrong if you redefine `respond_to?` for some class?

`respond_to?` vs. `respond_to_missing?`

<p>What is the point of defining <code>respond_to_missing?</code> as opposed to defining <code>respond_to?</code>? What goes wrong if you redefine <code>respond_to?</code> for some class?</p>


Trying to create objects and call methods dynamically by

    Object.const_get(class_name).new.send(method_name,parameters_array)

which is working fine when

    Object.const_get(RandomClass).new.send(i_take_arguments,[10.0])

but throwing wrong number of arguments 1 for 2 for

    Object.const_get(RandomClass).new.send(i_take_multiple_arguments,[25.0,26.0])

The Random Class defined is 

    class RandomClass
	def i_am_method_one
		puts &quot;I am method 1&quot;
	end
	def i_take_arguments(a)
		puts &quot;the argument passed is #{a}&quot;
	end
	def i_take_multiple_arguments(b,c)
		puts &quot;the arguments passed are #{b} and #{c}&quot;
	end
        end

Can someone help me on how to send mutiple parameters to a ruby method dynamically

ruby send method passing multiple parameters

In my code I had the following validation with Shoulda matchers, which works fine:

    it { should validate_presence_of(:name) }

In my model, I&#39;ve added the condition to my validation:

    validates_presence_of :name, :if =&gt; eligible?

Is it possible to reflect it in the validations?

I&#39;ve tried looking at [documentation][1] for shoulda matchers, but haven&#39;t been able to locate the solution.

Many thanks!


  [1]: https://github.com/thoughtbot/shoulda-matchers

Shoulda/RSpec matchers - conditional validation

I saw that they were documented together [here][1]. Are they the same thing? Why does Ruby have so many aliases (such as map/collect for arrays)? Thanks a lot.


  [1]: http://ruby-doc.org/core-1.9.3/Enumerable.html#method-i-reduce

Is inject the same thing as reduce in ruby?

I have following two elements in HTML 

    &lt;a href=&quot;/berlin&quot; &gt;Berlin&lt;/a&gt;
    &lt;a href=&quot;/berlin&quot; &gt;Berlin Germany &lt;/a&gt;

I am trying to find the element by using following Capybara method

    find(&quot;a&quot;, :text =&gt; &quot;berlin&quot;)

Above will return two elements because both contains text berlin. 

Is there a way to match exact text in Capybara ?

 

How to find an element by matching exact text of the element in Capybara

&gt; **Possible Duplicate:**  
&gt; [Shorter way to pass every element of an array to a function](https://stackoverflow.com/questions/13834846/shorter-way-to-pass-every-element-of-an-array-to-a-function)  

&lt;!-- End of automatically inserted text --&gt;

I know this will work:

    def inc(a)
      a+1
    end
    [1,2,3].map{|a| inc a}

but in Python, I just need to write:

    map(inc, [1,2,3])
or

    [inc(x) for x in [1,2,3])

I was wondering whether I can skip the steps of making a block in Ruby, and did this:

    [1,2,3].map inc
    # =&gt; ArgumentError: wrong number of arguments (0 for 1)
    # from (irb):19:in `inc&#39;

Does anyone have ideas about how to do this?

How to pass a function instead of a block

Being able to create and manipulate strings during compile-time in C++ has several useful applications. Although it is possible to create compile-time strings in C++, the process is very cumbersome, as the string needs to be declared as a variadic sequence of characters, e.g.

    using str = sequence&lt;&#39;H&#39;, &#39;e&#39;, &#39;l&#39;, &#39;l&#39;, &#39;o&#39;, &#39;,&#39;, &#39; &#39;, &#39;w&#39;, &#39;o&#39;, &#39;r&#39;, &#39;l&#39;, &#39;d&#39;, &#39;!&#39;&gt;;

Operations such as string concatenation, substring extraction, and many others, can easily be implemented as operations on sequences of characters. **Is it possible to declare compile-time strings more conveniently? If not, is there a proposal in the works that would allow for convenient declaration of compile-time strings?**

### Why Existing Approaches Fail

Ideally, we would like to be able to declare compile-time strings as follows:

    // Approach 1
    using str1 = sequence&lt;&quot;Hello, world!&quot;&gt;;

or, using user-defined literals,

    // Approach 2
    constexpr auto str2 = &quot;Hello, world!&quot;_s;

where `decltype(str2)` would have a `constexpr` constructor. A messier version of approach 1 is possible to implement, taking advantage of the fact that you can do the following:

    template &lt;unsigned Size, const char Array[Size]&gt;
    struct foo;

However, the array would need to have external linkage, so to get approach 1 to work, we would have to write something like this:

    /* Implementation of array to sequence goes here. */
    
    constexpr const char str[] = &quot;Hello, world!&quot;;
    
    int main()
    {
        using s = string&lt;13, str&gt;;
        return 0;
    }

Needless to say, this is very inconvenient. Approach 2 is actually not possible to implement. If we were to declare a (`constexpr`) literal operator, then how would we specify the return type? Since we need the operator to return a variadic sequence of characters, so we would need to use the `const char*` parameter to specify the return type:

    constexpr auto
    operator&quot;&quot; _s(const char* s, size_t n) -&gt; /* Some metafunction using `s` */

This results in a compile error, because `s` is not a `constexpr`. Trying to work around this by doing the following does not help much.

    template &lt;char... Ts&gt;
    constexpr sequence&lt;Ts...&gt; operator&quot;&quot; _s() { return {}; }

The standard dictates that this specific literal operator form is reserved for integer and floating-point types. While `123_s` would work, `abc_s` would not. What if we ditch user-defined literals altogether, and just use a regular `constexpr` function?

    template &lt;unsigned Size&gt;
    constexpr auto
    string(const char (&amp;array)[Size]) -&gt; /* Some metafunction using `array` */

As before, we run into the problem that the array, now a parameter to the `constexpr` function, is itself no longer a `constexpr` type.

I believe it should be possible to define a C preprocessor macro that takes a string and the size of the string as arguments, and returns a sequence consisting of the characters in the string (using `BOOST_PP_FOR`, stringification, array subscripts, and the like). However, I do not have the time (or enough interest) to implement such a macro =)

Conveniently Declaring Compile-Time Strings in C++

[Pony ORM][1] does the nice trick of converting a generator expression into SQL. Example:

    &gt;&gt;&gt; select(p for p in Person if p.name.startswith(&#39;Paul&#39;))
            .order_by(Person.name)[:2]

    SELECT &quot;p&quot;.&quot;id&quot;, &quot;p&quot;.&quot;name&quot;, &quot;p&quot;.&quot;age&quot;
    FROM &quot;Person&quot; &quot;p&quot;
    WHERE &quot;p&quot;.&quot;name&quot; LIKE &quot;Paul%&quot;
    ORDER BY &quot;p&quot;.&quot;name&quot;
    LIMIT 2

    [Person[3], Person[1]]
    &gt;&gt;&gt;

I know Python has wonderful introspection and metaprogramming builtin, but how this library is able to translate the generator expression without preprocessing? It looks like magic.

[update]

Blender wrote:
&gt; [Here is the file][2] that you&#39;re after. It seems to reconstruct the generator using some introspection wizardry. I&#39;m not sure if it supports 100% of Python&#39;s syntax, but this is pretty cool. – Blender

I was thinking they were exploring some feature from the generator expression protocol, but looking this file, and seeing the `ast` module involved... No, they are not inspecting the program source on the fly, are they? Mind-blowing...

@BrenBarn: If I try to call the generator outside the `select` function call, the result is:

    &gt;&gt;&gt; x = (p for p in Person if p.age &gt; 20)
    &gt;&gt;&gt; x.next()
    Traceback (most recent call last):
      File &quot;&lt;interactive input&gt;&quot;, line 1, in &lt;module&gt;
      File &quot;&lt;interactive input&gt;&quot;, line 1, in &lt;genexpr&gt;
      File &quot;C:\Python27\lib\site-packages\pony\orm\core.py&quot;, line 1822, in next
        % self.entity.__name__)
      File &quot;C:\Python27\lib\site-packages\pony\utils.py&quot;, line 92, in throw
        raise exc
    TypeError: Use select(...) function or Person.select(...) method for iteration
    &gt;&gt;&gt;

Seems like they are doing more arcane incantations like inspecting the `select` function call and processing the Python abstract syntax grammar tree on the fly.

I still would like to see someone explaining it, the source is way beyond my wizardry level.

  [1]: https://docs.ponyorm.org/
  [2]: https://github.com/ponyorm/pony/blob/orm/pony/orm/decompiling.py#L52

How Pony (ORM) does its tricks?

As far as I am aware there are three ways to dynamically call a method in Ruby:

Method 1:

    s = SomeObject.new
    method = s.method(:dynamic_method)
    method.call

Method 2:

    s = SomeObject.new
    s.send(:dynamic_method)

Method 3:
          
    s = SomeObject.new
    eval &quot;s.dynamic_method&quot;

By benchmarking them I have established that Method 1 is by far the fastest, Method 2 is slower, and Method 3 is by far the slowest.

I have also found that `.call` and `.send` both allow calling private methods, while `eval` does not.

So my question is: is there any reason to ever use `.send` or `eval`? Why would you not always just use the fastest method? What other differences do these methods of calling dynamic methods have?

Dynamic method calling in Ruby

If I define a little python program as

    class a():
        def _func(self):
            return &quot;asdf&quot;
    
        # Not sure what to resplace __init__ with so that a.func will return asdf
        def __init__(self, *args, **kwargs):
             setattr(self, &#39;func&#39;, classmethod(self._func))
   
    if __name__ == &quot;__main__&quot;:
        a.func

I receive the traceback error

    Traceback (most recent call last):
      File &quot;setattr_static.py&quot;, line 9, in &lt;module&gt;
        a.func
    AttributeError: class a has no attribute &#39;func&#39;

What I am trying to figure out is, how can I dynamically set a class method to a class without instantiating an object?

----
## Edit:

The answer for this problem is

    class a():
        pass
    
    def func(cls, some_other_argument):
        return some_other_argument
    
    setattr(a, &#39;func&#39;, classmethod(func))
    
    if __name__ == &quot;__main__&quot;:
        print(a.func)
        print(a.func(&quot;asdf&quot;))

returns the following output

    &lt;bound method type.func of &lt;class &#39;__main__.a&#39;&gt;&gt;
    asdf

How can I dynamically create class methods for a class in python

From something like this:

    print(get_indentation_level())

        print(get_indentation_level())

            print(get_indentation_level())

I would like to get something like this:

    1
    2
    3
Can the code read itself in this way?

All I want is the output from the more nested parts of the code to be more nested. In the same way that this makes code easier to read, it would make the output easier to read. 

Of course I could implement this manually, using e.g. `.format()`, but what I had in mind was a custom print function which would `print(i*&#39; &#39; + string)` where `i` is the indentation level. This would be a quick way to make readable output on my terminal. 

Is there a better way to do this which avoids painstaking manual formatting?

Content Type	Original Author	Original Content on Stackoverflow
Question	sawa	View Question on Stackoverflow
Solution 1 - Ruby	Andrew Marshall	View Answer on Stackoverflow
Solution 2 - Ruby	cesartalves	View Answer on Stackoverflow

`respond_to?` vs. `respond_to_missing?`

Ruby Problem Overview

Ruby Solutions

Solution 1 - Ruby

Solution 2 - Ruby

Why isn't a qualified static final variable allowed in a static initialization block?

iOS Chrome detection

Attributions