neocoin-mechanize 2.0.2

data/lib/mechanize/form/button.rb

@@ -0,0 +1,9 @@
+class Mechanize
+  class Form
+    # This class represents a Submit button in a form.
+    class Button < Field ; end
+    class Submit < Button; end
+    class Reset  < Button; end
+  end
+end
+

data/lib/mechanize/form/check_box.rb

@@ -0,0 +1,11 @@
+class Mechanize
+  class Form
+    # This class represents a check box found in a Form.  To activate the
+    # CheckBox in the Form, set the checked method to true.
+    class CheckBox < RadioButton
+      def query_value
+        [[@name, @value || "on"]]
+      end
+    end
+  end
+end

data/lib/mechanize/form/field.rb

@@ -0,0 +1,44 @@
+class Mechanize
+  class Form
+    # This class represents a field in a form.  It handles the following input
+    # tags found in a form:
+    # text, password, hidden, int, textarea
+    #
+    # To set the value of a field, just use the value method:
+    # field.value = "foo"
+    class Field
+      attr_accessor :name, :value, :node
+
+      def initialize node, value = node['value']
+        @node = node
+        @name = Util.html_unescape(node['name'])
+        @value = if value.is_a? String
+                   Util.html_unescape(value)
+                 else
+                   value
+                 end
+      end
+
+      def query_value
+        [[@name, @value || '']]
+      end
+
+      def <=> other
+        return 0 if self == other
+        return 1 if Hash === node
+        return -1 if Hash === other.node
+        node <=> other.node
+      end
+
+      # This method is a shortcut to get field's DOM id.
+      # Common usage: form.field_with(:dom_id => "foo")
+      def dom_id
+        node['id']
+      end
+    end
+
+    class Text     < Field; end
+    class Textarea < Field; end
+    class Hidden   < Field; end
+  end
+end

data/lib/mechanize/form/file_upload.rb

@@ -0,0 +1,23 @@
+class Mechanize
+  class Form
+    # This class represents a file upload field found in a form.  To use this
+    # class, set FileUpload#file_data= to the data of the file you want
+    # to upload and FileUpload#mime_type= to the appropriate mime type
+    # of the file.
+    # See the example in EXAMPLES[link://files/EXAMPLES_txt.html]
+    class FileUpload < Field
+      attr_accessor :file_name # File name
+      attr_accessor :mime_type # Mime Type (Optional)
+
+      alias :file_data :value
+      alias :file_data= :value=
+
+        def initialize node, file_name
+          @file_name = Util.html_unescape(file_name)
+          @file_data = nil
+          @node      = node
+          super(node, @file_data)
+        end
+    end
+  end
+end

data/lib/mechanize/form/image_button.rb

@@ -0,0 +1,20 @@
+class Mechanize
+  class Form
+    # This class represents an image button in a form.  Use the x and y methods
+    # to set the x and y positions for where the mouse "clicked".
+    class ImageButton < Button
+      attr_accessor :x, :y
+
+      def initialize *args
+        @x = nil
+        @y = nil
+        super
+      end
+
+      def query_value
+        [["#{@name}.x", (@x || 0).to_s],
+         ["#{@name}.y", (@y || 0).to_s]]
+      end
+    end
+  end
+end

data/lib/mechanize/form/multi_select_list.rb

@@ -0,0 +1,83 @@
+# This class represents a select list where multiple values can be selected.
+# MultiSelectList#value= accepts an array, and those values are used as
+# values for the select list.  For example, to select multiple values,
+# simply do this:
+#
+#  list.value = ['one', 'two']
+#
+# Single values are still supported, so these two are the same:
+#
+#  list.value = ['one']
+#  list.value = 'one'
+class Mechanize::Form::MultiSelectList < Mechanize::Form::Field
+  extend Mechanize::ElementMatcher
+
+  attr_accessor :options
+
+  def initialize node
+    value = []
+    @options = []
+
+    # parse
+    node.search('option').each do |n|
+      option = Mechanize::Form::Option.new(n, self)
+      @options << option
+    end
+    super(node, value)
+  end
+
+  ##
+  # Find one option on this select list with +criteria+
+  # Example:
+  #   select_list.option_with(:value => '1').value = 'foo'
+
+  ##
+  # Find all options on this select list with +criteria+
+  # Example:
+  #   select_list.options_with(:value => /1|2/).each do |field|
+  #     field.value = '20'
+  #   end
+
+  elements_with :option
+
+  def query_value
+    value ? value.collect { |v| [name, v] } : ''
+  end
+
+  # Select no options
+  def select_none
+    @value = []
+    options.each { |o| o.untick }
+  end
+
+  # Select all options
+  def select_all
+    @value = []
+    options.each { |o| o.tick }
+  end
+
+  # Get a list of all selected options
+  def selected_options
+    @options.find_all { |o| o.selected? }
+  end
+
+  def value=(values)
+    select_none
+    [values].flatten.each do |value|
+      option = options.find { |o| o.value == value }
+      if option.nil?
+        @value.push(value)
+      else
+        option.select
+      end
+    end
+  end
+
+  def value
+    value = []
+    value.push(*@value)
+    value.push(*selected_options.collect { |o| o.value })
+    value
+  end
+
+end

data/lib/mechanize/form/option.rb

@@ -0,0 +1,49 @@
+class Mechanize
+  class Form
+    # This class contains option an option found within SelectList.  A
+    # SelectList can have many Option classes associated with it.  An option
+    # can be selected by calling Option#tick, or Option#click.  For example,
+    # select the first option in a list:
+    #  select_list.first.tick
+    class Option
+      attr_reader :value, :selected, :text, :select_list
+
+      alias :to_s :value
+      alias :selected? :selected
+
+      def initialize(node, select_list)
+        @text     = node.inner_text
+        @value    = Util.html_unescape(node['value'] || node.inner_text)
+        @selected = node.has_attribute? 'selected'
+        @select_list = select_list # The select list this option belongs to
+      end
+
+      # Select this option
+      def select
+        unselect_peers
+        @selected = true
+      end
+
+      # Unselect this option
+      def unselect
+        @selected = false
+      end
+
+      alias :tick   :select
+      alias :untick :unselect
+
+      # Toggle the selection value of this option
+      def click
+        unselect_peers
+        @selected = !@selected
+      end
+
+      private
+      def unselect_peers
+        if @select_list.instance_of? SelectList
+          @select_list.select_none
+        end
+      end
+    end
+  end
+end

data/lib/mechanize/form/radio_button.rb

@@ -0,0 +1,48 @@
+class Mechanize
+  class Form
+    # This class represents a radio button found in a Form.  To activate the
+    # RadioButton in the Form, set the checked method to true.
+    class RadioButton < Field
+      attr_accessor :checked
+
+      def initialize node, form
+        @checked = !!node['checked']
+        @form    = form
+        super(node)
+      end
+
+      def check
+        uncheck_peers
+        @checked = true
+      end
+
+      def uncheck
+        @checked = false
+      end
+
+      def click
+        checked ? uncheck : check
+      end
+
+      def label
+        (id = self['id']) && @form.page.labels_hash[id] || nil
+      end
+
+      def text
+        label.text rescue nil
+      end
+
+      def [](key)
+        @node[key]
+      end
+
+      private
+      def uncheck_peers
+        @form.radiobuttons_with(:name => name).each do |b|
+          next if b.value == value
+          b.uncheck
+        end
+      end
+    end
+  end
+end

data/lib/mechanize/form/select_list.rb

@@ -0,0 +1,40 @@
+  # This class represents a select list or drop down box in a Form.  Set the
+  # value for the list by calling SelectList#value=.  SelectList contains a
+  # list of Option that were found.  After finding the correct option, set
+  # the select lists value to the option value:
+  #  selectlist.value = selectlist.options.first.value
+  # Options can also be selected by "clicking" or selecting them.  See Option
+class Mechanize::Form::SelectList < Mechanize::Form::MultiSelectList
+  def initialize node
+    super
+    if selected_options.length > 1
+      selected_options.reverse[1..selected_options.length].each do |o|
+        o.unselect
+      end
+    end
+  end
+
+  def value
+    value = super
+    if value.length > 0
+      value.last
+    elsif @options.length > 0
+      @options.first.value
+    else
+      nil
+    end
+  end
+
+  def value=(new)
+    if new != new.to_s and new.respond_to? :first
+      super([new.first])
+    else
+      super([new.to_s])
+    end
+  end
+
+  def query_value
+    value ? [[name, value]] : nil
+  end
+end
+

data/lib/mechanize/headers.rb

@@ -0,0 +1,25 @@
+class Mechanize
+  class Headers < Hash
+    def [](key)
+      super(key.downcase)
+    end
+
+    def []=(key, value)
+      super(key.downcase, value)
+    end
+
+    def key?(key)
+      super(key.downcase)
+    end
+
+    def canonical_each
+      block_given? or return enum_for(__method__)
+      each { |key, value|
+        key = key.capitalize
+        key.gsub!(/-([a-z])/) { "-#{$1.upcase}" }
+        yield [key, value]
+      }
+    end
+  end
+end
+

data/lib/mechanize/history.rb

@@ -0,0 +1,83 @@
+class Mechanize
+  ##
+  # This class manages history for your mechanize object.
+  class History < Array
+    attr_accessor :max_size
+
+    def initialize(max_size = nil)
+      @max_size       = max_size
+      @history_index  = {}
+    end
+
+    def initialize_copy(orig)
+      super
+      @history_index = orig.instance_variable_get(:@history_index).dup
+    end
+
+    def inspect # :nodoc:
+      uris = map { |page| page.uri }.join ', '
+
+      "[#{uris}]"
+    end
+
+    def push(page, uri = nil)
+      super(page)
+
+      @history_index[(uri ? uri : page.uri).to_s] = page
+
+      if @max_size && self.length > @max_size
+        while self.length > @max_size
+          self.shift
+        end
+      end
+
+      self
+    end
+    alias :<< :push
+
+    def visited_page(uri)
+      page = @history_index[uri.to_s]
+
+      return page if page # HACK
+
+      uri = uri.dup
+      uri.path = '/' if uri.path.empty?
+
+      @history_index[uri.to_s]
+    end
+
+    alias visited? visited_page
+
+    def clear
+      @history_index.clear
+      super
+    end
+
+    def shift
+      return nil if length == 0
+      page    = self[0]
+      self[0] = nil
+
+      super
+
+      remove_from_index(page)
+      page
+    end
+
+    def pop
+      return nil if length == 0
+      page = super
+      remove_from_index(page)
+      page
+    end
+
+    private
+
+    def remove_from_index(page)
+      @history_index.each do |k,v|
+        @history_index.delete(k) if v == page
+      end
+    end
+
+  end
+end