zinfinit-actionwebservice 2.3.4.2

data/lib/action_web_service/simple.rb

@@ -0,0 +1,53 @@
+module ActionWebService
+  # To send simple types across the wire, derive from ActionWebService::Simple,
+  # and use +base+ to declare the base type for it restriction and,
+  # use +restriction+ to declare valid W3C restriction element for SimpleType.
+  #
+  # ActionWebService::Simple should be used when you want to declare valid custom simple type
+  # to be used inside expects, returns and structured types
+  #
+  #
+  # There plenty documentation available at W3C Archives
+  # http://www.w3.org/TR/xmlschema-2/
+  #
+  # === Example
+  #
+  #   class Gender < ActionWebService::Simple
+  #     base :string
+  #     restriction :enumeration, "male|female"
+  #   end
+  #
+  #
+  class Simple
+
+    def initialize(value)
+      @value = value
+    end
+    
+    class << self
+      def base(type)
+        type = type.to_s.camelize(:lower)
+        write_inheritable_attribute("xml_base", type)
+        class_eval <<-END
+          def xml_base; "#{type}"; end
+        END
+      end
+      
+      def restriction_base
+        read_inheritable_attribute("xml_base") || ""
+      end
+      
+      def restriction(type, value)
+        type = type.to_s.camelize(:lower)
+        write_inheritable_hash("simple_restrictions", type => value)
+      end
+      
+      def restrictions
+        read_inheritable_attribute("simple_restrictions") || {}
+      end
+      
+    end
+
+  end
+
+end

data/lib/action_web_service/string_to_datetime_for_soap.rb

@@ -0,0 +1,10 @@
+module StringToDatetimeForSoap
+  def to_datetime
+    if /^([+\-]?\d{4,})-(\d\d)-(\d\d)T(\d\d):(\d\d):(\d\d(?:\.(\d*))?)(Z|(?:[+\-]\d\d:\d\d)?)?$/ =~ self.strip
+      return Time.xmlschema(self).localtime
+    end
+    super
+  end
+end
+
+String.send :include, StringToDatetimeForSoap

data/lib/action_web_service/struct.rb

@@ -0,0 +1,68 @@
+module ActionWebService
+  # To send structured types across the wire, derive from ActionWebService::Struct,
+  # and use +member+ to declare structure members.
+  #
+  # ActionWebService::Struct should be used in method signatures when you want to accept or return
+  # structured types that have no Active Record model class representations, or you don't
+  # want to expose your entire Active Record model to remote callers.
+  #
+  # === Example
+  #
+  #   class Person < ActionWebService::Struct
+  #     member :id,         :int
+  #     member :firstnames, [:string]
+  #     member :lastname,   :string
+  #     member :email,      :string
+  #   end
+  #   person = Person.new(:id => 5, :firstname => 'john', :lastname => 'doe')
+  #
+  # Active Record model classes are already implicitly supported in method
+  # signatures.
+  class Struct
+    # If a Hash is given as argument to an ActionWebService::Struct constructor,
+    # it can contain initial values for the structure member.
+    def initialize(values={})
+      if values.is_a?(Hash)
+        values.map do |k,v| 
+          __send__('%s=' % k.to_s, v)
+        end
+      end
+    end
+
+    # The member with the given name
+    def [](name)
+      send(name.to_s)
+    end
+
+    # Iterates through each member
+    def each_pair(&block)
+      self.class.members.each do |name, type|
+        yield name, self.__send__(name)
+      end
+    end
+
+    class << self
+      # Creates a structure member with the specified +name+ and +type+. Generates
+      # accessor methods for reading and writing the member value.
+      def member(name, type)
+        name = name.to_sym
+        type = ActionWebService::SignatureTypes.canonical_signature_entry({ name => type }, 0)
+        write_inheritable_hash("struct_members", name => type)
+        class_eval <<-END
+          def #{name}; @#{name}; end
+          def #{name}=(value)
+            @#{name} = value;
+          end
+        END
+      end
+  
+      def members # :nodoc:
+        read_inheritable_attribute("struct_members") || {}
+      end
+
+      def member_type(name) # :nodoc:
+        members[name.to_sym]
+      end
+    end
+  end
+end

data/lib/action_web_service/support/class_inheritable_options.rb

@@ -0,0 +1,26 @@
+class Class # :nodoc:
+  def class_inheritable_option(sym, default_value=nil)
+    write_inheritable_attribute sym, default_value
+    class_eval <<-EOS
+      def self.#{sym}(value=nil)
+        if !value.nil?
+          write_inheritable_attribute(:#{sym}, value)
+        else
+          read_inheritable_attribute(:#{sym})
+        end
+      end
+      
+      def self.#{sym}=(value)
+        write_inheritable_attribute(:#{sym}, value)
+      end
+
+      def #{sym}
+        self.class.#{sym}
+      end
+
+      def #{sym}=(value)
+        self.class.#{sym} = value
+      end
+    EOS
+  end
+end

data/lib/action_web_service/support/signature_types.rb

@@ -0,0 +1,256 @@
+module ActionWebService # :nodoc:
+  # Action Web Service supports the following base types in a signature:
+  #
+  # [<tt>:int</tt>]      Represents an integer value, will be cast to an integer using <tt>Integer(value)</tt>
+  # [<tt>:string</tt>]   Represents a string value, will be cast to an string using the <tt>to_s</tt> method on an object
+  # [<tt>:base64</tt>]   Represents a Base 64 value, will contain the binary bytes of a Base 64 value sent by the caller
+  # [<tt>:bool</tt>]     Represents a boolean value, whatever is passed will be cast to boolean (<tt>true</tt>, '1', 'true', 'y', 'yes' are taken to represent true; <tt>false</tt>, '0', 'false', 'n', 'no' and <tt>nil</tt> represent false)
+  # [<tt>:float</tt>]    Represents a floating point value, will be cast to a float using <tt>Float(value)</tt>
+  # [<tt>:time</tt>]     Represents a timestamp, will be cast to a <tt>Time</tt> object
+  # [<tt>:datetime</tt>] Represents a timestamp, will be cast to a <tt>DateTime</tt> object
+  # [<tt>:date</tt>]     Represents a date, will be cast to a <tt>Date</tt> object
+  #
+  # For structured types, you'll need to pass in the Class objects of
+  # ActionWebService::Struct and ActiveRecord::Base derivatives.
+  module SignatureTypes
+    def canonical_signature(signature) # :nodoc:
+      return nil if signature.nil?
+      unless signature.is_a?(Array)
+        raise(ActionWebServiceError, "Expected signature to be an Array")
+      end
+      i = -1
+      signature.map{ |spec| canonical_signature_entry(spec, i += 1) }
+    end
+
+    def canonical_signature_entry(spec, i) # :nodoc:
+      orig_spec = spec
+      name = "param#{i}"
+      if spec.is_a?(Hash)
+        name, spec = spec.keys.first, spec.values.first
+      end
+      type = spec
+      if spec.is_a?(Array)
+        ArrayType.new(orig_spec, canonical_signature_entry(spec[0], 0), name)
+      else
+        type = canonical_type(type)
+        if type.is_a?(Symbol)
+          BaseType.new(orig_spec, type, name)
+        else 
+          if type.is_a?(Hash)
+            complexity, type = type.keys.first.to_sym, type.values.first 
+          end
+          element = complexity || :complex
+          element == :simple ? SimpleType.new(orig_spec, type, name) : StructuredType.new(orig_spec, type, name)
+        end
+      end
+    end
+
+    def canonical_type(type) # :nodoc:
+      type_name = symbol_name(type) || class_to_type_name(type)
+      type = type_name || type
+      return canonical_type_name(type) if type.is_a?(Symbol)
+      type
+    end
+
+    def canonical_type_name(name) # :nodoc:
+      name = name.to_sym
+      case name
+        when :int, :integer, :fixnum, :bignum
+          :int
+        when :string, :text
+          :string
+        when :base64, :binary
+          :base64
+        when :bool, :boolean
+          :bool
+        when :float, :double
+          :float
+        when :decimal
+          :decimal
+        when :time, :timestamp
+          :time
+        when :datetime
+          :datetime
+        when :date
+          :date
+        else
+          raise(TypeError, "#{name} is not a valid base type")
+      end
+    end
+
+    def canonical_type_class(type) # :nodoc:
+      type = canonical_type(type)
+      type.is_a?(Symbol) ? type_name_to_class(type) : type
+    end
+
+    def symbol_name(name) # :nodoc:
+      return name.to_sym if name.is_a?(Symbol) || name.is_a?(String)
+      nil
+    end
+
+    def class_to_type_name(klass) # :nodoc:
+      klass = klass.class unless klass.is_a?(Class)
+      if derived_from?(Integer, klass) || derived_from?(Fixnum, klass) || derived_from?(Bignum, klass)
+        :int
+      elsif klass == String
+        :string
+      elsif klass == Base64
+        :base64
+      elsif klass == TrueClass || klass == FalseClass
+        :bool
+      elsif derived_from?(Float, klass) || derived_from?(Precision, klass) || derived_from?(Numeric, klass)
+        :float
+      elsif klass == Time
+        :time
+      elsif klass == DateTime
+        :datetime
+      elsif klass == Date
+        :date
+      else
+        nil
+      end
+    end
+
+    def type_name_to_class(name) # :nodoc:
+      case canonical_type_name(name)
+      when :int
+        Integer
+      when :string
+        String
+      when :base64
+        Base64
+      when :bool
+        TrueClass
+      when :float
+        Float
+      when :decimal
+        BigDecimal
+      when :time
+        Time
+      when :date
+        Date
+      when :datetime
+        DateTime
+      else
+        nil
+      end
+    end
+
+    def derived_from?(ancestor, child) # :nodoc:
+      child.ancestors.include?(ancestor)
+    end
+
+    module_function :type_name_to_class
+    module_function :class_to_type_name
+    module_function :symbol_name
+    module_function :canonical_type_class
+    module_function :canonical_type_name
+    module_function :canonical_type
+    module_function :canonical_signature_entry
+    module_function :canonical_signature
+    module_function :derived_from?
+  end
+
+  class BaseType # :nodoc:
+    include SignatureTypes
+
+    attr :spec
+    attr :type
+    attr :type_class
+    attr :name
+
+    def initialize(spec, type, name)
+      @spec = spec
+      @type = canonical_type(type)
+      @type_class = canonical_type_class(@type)
+      @name = name
+    end
+
+    def custom?
+      false
+    end
+
+    def array?
+      false
+    end
+
+    def structured?
+      false
+    end
+    
+    def simple?
+      false
+    end
+
+    def human_name(show_name=true)
+      type_type = array? ? element_type.type.to_s : self.type.to_s
+      str = array? ? (type_type + '[]') : type_type
+      show_name ? (str + " " + name.to_s) : str
+    end
+  end
+
+  class ArrayType < BaseType # :nodoc:
+    attr :element_type
+
+    def initialize(spec, element_type, name)
+      super(spec, Array, name)
+      @element_type = element_type
+    end
+
+    def custom?
+      true
+    end
+
+    def array?
+      true
+    end
+  end
+
+  class StructuredType < BaseType # :nodoc:
+    def each_member
+      if @type_class.respond_to?(:members)
+        @type_class.members.each do |name, type|
+          yield name, type
+        end
+      elsif @type_class.respond_to?(:columns)
+        i = -1
+        @type_class.columns.each do |column|
+          yield column.name, canonical_signature_entry(column.type, i += 1)
+        end
+      end
+    end
+
+    def custom?
+      true
+    end
+
+    def structured?
+      true
+    end
+  end
+  
+  class SimpleType < BaseType # :nodoc:
+    def base
+      @type_class.restriction_base if @type_class.respond_to?(:restriction_base)
+    end
+    
+    def restrictions
+      if @type_class.respond_to?(:restrictions)
+        @type_class.restrictions.each do |name, value|
+          yield name, value
+        end
+      end
+    end
+    
+    def custom?
+      true
+    end
+    
+    def simple?
+      true
+    end
+  end
+
+  class Base64 < String # :nodoc:
+  end
+end

data/lib/action_web_service/templates/scaffolds/layout.html.erb

@@ -0,0 +1,65 @@
+<html>
+<head>
+  <title><%= @scaffold_class.wsdl_service_name %> Web Service</title>
+  <style>
+    body { background-color: #fff; color: #333; }
+
+    body, p, ol, ul, td {
+      font-family: verdana, arial, helvetica, sans-serif;
+      font-size:   13px;
+      line-height: 18px;
+    }
+
+    pre {
+      background-color: #eee;
+      padding: 10px;
+      font-size: 11px;
+    }
+
+    a { color: #000; }
+    a:visited { color: #666; }
+    a:hover { color: #fff; background-color:#000; }
+
+    .fieldWithErrors {
+      padding: 2px;
+      background-color: red;
+      display: table;
+    }
+
+    #errorExplanation {
+      width: 400px;
+      border: 2px solid red;
+      padding: 7px;
+      padding-bottom: 12px;
+      margin-bottom: 20px;
+      background-color: #f0f0f0;
+    }
+
+    #errorExplanation h2 {
+      text-align: left;
+      font-weight: bold;
+      padding: 5px 5px 5px 15px;
+      font-size: 12px;
+      margin: -7px;
+      background-color: #c00;
+      color: #fff;
+    }
+
+    #errorExplanation p {
+      color: #333;
+      margin-bottom: 0;
+      padding: 5px;
+    }
+
+    #errorExplanation ul li {
+      font-size: 12px;
+      list-style: square;
+    }
+  </style>
+</head>
+<body>
+
+<%= @content_for_layout %>
+
+</body>
+</html>