class FormInput

# File lib/form_input/core.rb, line 629
def []( *names )
  if names.count == 1
    form_params[ names.first ]
  else
    form_params.values_at( *names )
  end
end

# File lib/form_input/core.rb, line 727
def array( name, *args, &block )
  param( name, *args, array: true, &block )
end

# File lib/form_input/core.rb, line 732
def array!( name, *args, &block )
  param!( name, *args, array: true, &block )
end

# File lib/form_input/core.rb, line 652
def copy( source, opts = {} )
  case source
  when Parameter
    add( Parameter.new(
      opts[ :name ] || source.name,
      opts[ :code ] || opts[ :name ] || source.code,
      source.opts.merge( opts )
    ) )
  when Array
    source.each{ |x| copy( x, opts ) }
  when Class
    fail ArgumentError, "invalid source form #{source.inspect}" unless source < FormInput
    copy( source.form_params.values, opts )
  else
    fail ArgumentError, "invalid source parameter #{source.inspect}"
  end
  self
end

# File lib/form_input/localize.rb, line 43
def self.default_translation( forms = self.forms )
  hash = Hash[ forms.map{ |x| [ x.translation_name, x.translation_hash ] }.reject{ |k, v| v.empty? } ]
  YAML::dump( { forms: hash }.stringify_keys )
end

# File lib/form_input/steps.rb, line 7
def self.define_steps( steps )
  @steps = steps = steps.to_hash.dup.freeze

  self.send( :include, StepMethods )

  opts = { filter: ->{ steps.keys.find{ |x| x.to_s == self } }, class: Symbol }

  param :step, opts, type: :hidden
  param :next, opts, type: :ignore
  param :last, opts, type: :hidden
  param :seen, opts, type: :hidden

  self
end

# File lib/form_input/r18n.rb, line 129
def self.find_inflection( string )
  until string.empty?
    break if result = yield( string )
    string = string[0..-2]
  end
  result
end

# File lib/form_input/core.rb, line 624
def form_params
  @params ||= {}
end

# File lib/form_input/steps.rb, line 23
def self.form_steps
  @steps
end

# File lib/form_input/localize.rb, line 38
def self.forms
  ObjectSpace.each_object( Class ).select{ |x| x < FormInput and x.name }.sort_by{ |x| x.name }
end

# File lib/form_input/core.rb, line 758
def from_hash( hash )
  new.set( hash )
end

# File lib/form_input/core.rb, line 752
def from_params( params )
  new.import( params )
end

# File lib/form_input/core.rb, line 747
def from_request( request )
  new.import( request )
end

# File lib/form_input/core.rb, line 737
def hash( name, *args, &block )
  param( name, *args, hash: true, &block )
end

# File lib/form_input/core.rb, line 742
def hash!( name, *args, &block )
  param!( name, *args, hash: true, &block )
end

# File lib/form_input/core.rb, line 619
def inherited( into )
  into.instance_variable_set( '@params', form_params.dup )
end

# File lib/form_input/core.rb, line 775
def initialize( *args )
  @params = bound_params
  @errors = nil
  for arg in args
    if arg.is_a? Hash
      set( arg )
    else
      import( arg )
    end
  end
end

# File lib/form_input/core.rb, line 676
def param( name, *args, &block )

  # Fetch arguments.

  code = name
  code = args.shift if args.first.is_a? Symbol

  title = args.shift if args.first.is_a? String

  size = args.shift if args.first.is_a? Numeric

  opts = {}
  opts.merge!( args.shift ){ |k, o, n| ( n && MERGEABLE_OPTIONS.include?( k ) ) ? [ *o, *n ] : n } while args.first.is_a? Hash

  fail ArgumentError, "invalid arguments #{args}" unless args.empty?

  # Set the title.

  opts[ :title ] = title.freeze if title

  # Set input filter.

  opts[ :filter ] = block if block
  opts[ :filter ] = DEFAULT_FILTER unless opts.key?( :filter )

  # Enforce default size limits for any input processed.

  limit = DEFAULT_SIZE_LIMIT

  size = ( opts[ :max_size ] ||= size || limit )
  opts[ :max_bytesize ] ||= limit if size.is_a?( Proc ) or size <= limit

  # Set default key limits for hash parameters.

  if opts[ :hash ]
    opts[ :min_key ] ||= DEFAULT_MIN_KEY
    opts[ :max_key ] ||= DEFAULT_MAX_KEY
  end

  # Define parameter.

  add( Parameter.new( name, code, opts ) )
  self
end

# File lib/form_input/core.rb, line 722
def param!( name, *args, &block )
  param( name, *args, required: true, &block )
end

# File lib/form_input/types.rb, line 143
def self.parse_time( string, format )
  format = format.gsub( /%[-_^]?(.)/, '%\1' )
  # Rather than using _strptime and checking the leftover field,
  # add required trailing character to both the string and format parameters.
  suffix = ( string[ -1 ] == "\1" ? "\2" : "\1" )
  Time.strptime( "+0000 #{string}#{suffix}", "%z #{format}#{suffix}" ).utc
end

# File lib/form_input/types.rb, line 152
def self.parse_time!( string, format )
  parse_time( string, format )
rescue
  DateTime.parse( string ).to_time.utc
end

# File lib/form_input/localize.rb, line 31
def self.translation_hash
  hash = Hash[ form_params.map{ |k, v| [ k, v.translation_hash ] }.reject{ |k, v| v.empty? } ]
  hash[ :steps ] = form_steps.reject{ |k, v| v.nil? } if form_steps
  hash
end

# File lib/form_input/r18n.rb, line 112
def self.translation_name
  @translation_name ||= name.split( '::' ).last
    .gsub( /([A-Z]+)([A-Z][a-z])/, '\1_\2' )
    .gsub( /([a-z\d])([A-Z])/, '\1_\2' )
    .downcase
end

# File lib/form_input/r18n.rb, line 107
def self.translations_path
  File.expand_path( "#{__FILE__}/../r18n" )
end

# File lib/form_input/core.rb, line 638
def add( param )
  name = param.name

  fail ArgumentError, "duplicate parameter #{name}" if form_params[ name ]
  fail ArgumentError, "invalid parameter name #{name}" if method_defined?( name )

  self.send( :attr_accessor, name )

  form_params[ name ] = param
end

# File lib/form_input/core.rb, line 890
def []( *names )
  if names.count == 1
    send( names.first )
  else
    names.map{ |x| send( x ) }
  end
end

# File lib/form_input/core.rb, line 900
def []=( name, value )
  @errors = nil
  send( "#{name}=", value )
end

# File lib/form_input/core.rb, line 1060
def array_params
  params.select{ |x| x.array? }
end

# File lib/form_input/core.rb, line 988
def blank_params
  params.select{ |x| x.blank? }
end

# File lib/form_input/core.rb, line 1138
def build_url( url, args = {} )
  dup.set( args ).extend_url( url )
end

# File lib/form_input/core.rb, line 1102
def chunked_params( params = self.params )
  params.chunk{ |p| p[ :row ] || :_alone }.map{ |x,a| a.count > 1 ? a : a.first }
end

# File lib/form_input/core.rb, line 879
def clear( *names )
  names = names.empty? ? params_names : validate_names( names )
  for name in names
    # Set the value to nil first so it triggers anything necessary.
    self[ name ] = nil
    remove_instance_variable( "@#{name}" )
  end
  self
end

# File lib/form_input/core.rb, line 976
def correct_params
  params.select{ |x| x.correct? }
end

# File lib/form_input/core.rb, line 1030
def disabled_params
  params.select{ |x| x.disabled? }
end

# File lib/form_input/core.rb, line 1109
def empty?
  filled_params.empty?
end

# File lib/form_input/core.rb, line 994
def empty_params
  params.select{ |x| x.empty? }
end

# File lib/form_input/core.rb, line 1036
def enabled_params
  params.select{ |x| x.enabled? }
end

# File lib/form_input/core.rb, line 1179
def error_for( name )
  errors_for( name ).first
end

# File lib/form_input/core.rb, line 1151
def error_messages
  errors.values.map{ |x| x.first }
end

# File lib/form_input/core.rb, line 1145
def errors
  validate?
  @errors.dup
end

# File lib/form_input/core.rb, line 1174
def errors_for( name )
  errors[ name ] || []
end

# File lib/form_input/core.rb, line 936
def except( *names )
  dup.clear( names )
end

# File lib/form_input/core.rb, line 1128
def extend_url( url )
  url = url.to_s.dup
  query = url_query
  unless query.empty?
    url << ( url['?'] ? '&' : '?' ) << query
  end
  url
end

# File lib/form_input/core.rb, line 1000
def filled_params
  params.select{ |x| x.filled? }
end

# File lib/form_input/core.rb, line 802
def freeze
  unless frozen?
    validate?
    @errors.freeze.each{ |k,v| v.freeze }
  end
  super
end

# File lib/form_input/r18n.rb, line 121
def ft( *args )
  fail "You need to set the locale with R18n.set('en') or similar. No locale, no helper. Sorry." unless r18n
  translation = t.forms[ self.class.translation_name ]
  args.empty? ? translation : translation[ *args ]
end

# File lib/form_input/core.rb, line 1066
def hash_params
  params.select{ |x| x.hash? }
end

# File lib/form_input/core.rb, line 1042
def hidden_params
  params.select{ |x| x.hidden? }
end

# File lib/form_input/core.rb, line 1048
def ignored_params
  params.select{ |x| x.ignored? }
end

# File lib/form_input/core.rb, line 847
def import( request )
  hash = request.respond_to?( :params ) ? request.params : request.to_hash
  for name, param in @params
    value = hash.fetch( param.code ) { hash.fetch( param.code.to_s, self ) }
    unless value == self
      value = sanitize_value( value, param.filter )
      if transform = param.transform
        value = value.instance_exec( &transform )
      end
      self[ name ] = value
    end
  end
  self
end

# File lib/form_input/core.rb, line 982
def incorrect_params
  params.select{ |x| x.incorrect? }
end

# File lib/form_input/core.rb, line 788
def initialize_clone( other )
  super
  @params = bound_params
  @errors &&= Hash[ @errors.map{ |k,v| [ k, v.clone ] } ]
end

# File lib/form_input/core.rb, line 795
def initialize_dup( other )
  super
  @params = bound_params
  @errors = nil
end

# File lib/form_input/core.rb, line 1193
def invalid?( *names )
  not valid?( *names )
end

# File lib/form_input/core.rb, line 1096
def invalid_params
  params.select{ |x| x.invalid? }
end

# File lib/form_input/core.rb, line 970
def named_params( *names )
  @params.values_at( *names )
end

# File lib/form_input/core.rb, line 941
def only( *names )
  # It would be easier to create new instance here and only copy selected values,
  # but we want to use dup instead of new here, as the derived form can use
  # different parameters in its construction.
  dup.clear( params_names - validate_names( names ) )
end

# File lib/form_input/core.rb, line 1024
def optional_params
  params.select{ |x| x.optional? }
end

# File lib/form_input/core.rb, line 951
def param( name )
  @params[ name ]
end

# File lib/form_input/core.rb, line 957
def params
  @params.values
end

# File lib/form_input/core.rb, line 963
def params_names
  @params.keys
end

# File lib/form_input/core.rb, line 1158
def report( name, msg )
  validate?
  ( @errors[ name ] ||= [] ) << msg.to_s.dup.freeze
  self
end

# File lib/form_input/core.rb, line 1167
def report!( name, msg )
  validate?
  ( @errors[ name ] ||= [] ).unshift( msg.to_s.dup.freeze )
  self
end

# File lib/form_input/core.rb, line 1018
def required_params
  params.select{ |x| x.required? }
end

# File lib/form_input/core.rb, line 1072
def scalar_params
  params.select{ |x| x.scalar? }
end

# File lib/form_input/core.rb, line 864
def set( hash )
  for name, value in hash
    self[ name ] = value
  end
  self
end

# File lib/form_input/core.rb, line 1006
def set_params
  params.select{ |x| x.set? }
end

# File lib/form_input/core.rb, line 1078
def tagged_params( *tags )
  params.select{ |x| x.tagged?( *tags ) }
end

# File lib/form_input/core.rb, line 919
def to_data
  result = {}
  set_params.each{ |x| result[ x.code ] = x.value }
  result
end

# File lib/form_input/core.rb, line 908
def to_hash
  result = {}
  filled_params.each{ |x| result[ x.name ] = x.value }
  result
end

# File lib/form_input/core.rb, line 873
def unset( name, *names )
  clear( name, *names )
end

# File lib/form_input/core.rb, line 1012
def unset_params
  params.select{ |x| x.unset? }
end

# File lib/form_input/core.rb, line 1084
def untagged_params( *tags )
  params.select{ |x| x.untagged?( *tags ) }
end

# File lib/form_input/core.rb, line 1114
def url_params
  result = {}
  filled_params.each{ |x| result[ x.code ] = x.form_value }
  result
end

# File lib/form_input/core.rb, line 1123
def url_query
  Rack::Utils.build_nested_query( url_params )
end

# File lib/form_input/core.rb, line 1198
def valid( name, *names )
  self[ name, *names ] if valid?( name, *names )
end

# File lib/form_input/core.rb, line 1184
def valid?( *names )
  if names.empty?
    errors.empty?
  else
    validate_names( names ).all?{ |x| errors_for( x ).empty? }
  end
end

# File lib/form_input/core.rb, line 1090
def valid_params
  params.select{ |x| x.valid? }
end

# File lib/form_input/core.rb, line 1206
def validate
  @errors ||= {}
  params.each{ |x| x.validate }
  self
end

# File lib/form_input/core.rb, line 1214
def validate!
  @errors = {}
  validate
  self
end

# File lib/form_input/core.rb, line 1222
def validate?
  validate unless @errors
  self
end

# File lib/form_input/core.rb, line 1054
def visible_params
  params.select{ |x| x.visible? }
end

# File lib/form_input/core.rb, line 767
def bound_params
  hash = {}
  self.class.form_params.each{ |name, param| hash[ name ] = param.dup.bind( self ) }
  hash.freeze
end

# File lib/form_input/core.rb, line 811
def sanitize_value( value, filter = nil )
  case value
  when String
    # Note that Rack does no encoding processing as of now,
    # and even if we know content type charset, the query charset
    # is not well defined and we can't fix the multi-part input here either.
    # So we just hope that all clients will send the data in UTF-8 which we used in the form,
    # and enforce everything to UTF-8. If it is not valid, we keep the binary string instead
    # so the validation can detect it but the user can still process it himself if he wants to.
    value = value.dup.force_encoding( DEFAULT_ENCODING )
    if value.valid_encoding?
      value = value.instance_exec( &filter ) if filter
    else
      value.force_encoding( Encoding::BINARY )
    end
    value
  when Array
    # Arrays are supported, but note that the validation done later only allows flat arrays.
    value.map{ |x| sanitize_value( x, filter ) }
  when Hash
    # To reduce security issues, we prefer integer hash keys only.
    # The validation done later ensures that the keys are valid, within range,
    # and that only flat hashes are allowed.
    Hash[ value.map{ |k, v| [ ( Integer( k, 10 ) rescue k ), sanitize_value( v, filter ) ] } ]
  when Numeric, TrueClass, FalseClass, NilClass
    # For convenience of importing JSON payloads, allow each of these simple scalar types as they are.
    # The validation done later will ensure that the type class matches the parameter.
    value
  else
    fail TypeError, "unexpected parameter type"
  end
end

# File lib/form_input/core.rb, line 926
def validate_names( names )
  names.flatten.map do |name|
    name = name.name if name.is_a? Parameter
    fail( ArgumentError, "unknown parameter #{name}" ) unless @params[ name ]
    name
  end
end