# fluri 1.2.3

Fluri is a fluent URI library built to make URI mutation easy.




## Installing
```
export PUB_HOSTED_URL=https://pub.mirror.p-hatan.ir
flutter pub add 'fluri:1.2.3'
```
Published: 2017-07-05T20:17:36.394115Z
Expected archive SHA-256: 1145c6039b56be7bd9c97659c004695f04c3649111211b16b99d73d18fe882c2

Available in cache; verification: upstream_checksum
## Direct dependencies

## Package README (untrusted upstream documentation)
# fluri 
[![Pub](https://img.shields.io/pub/v/fluri.svg)](https://pub.dartlang.org/packages/fluri)
[![Build Status](https://travis-ci.org/Workiva/fluri.svg?branch=master)](https://travis-ci.org/Workiva/fluri)
[![codecov.io](http://codecov.io/github/Workiva/fluri/coverage.svg?branch=master)](http://codecov.io/github/Workiva/fluri?branch=master)
[![documentation](https://img.shields.io/badge/Documentation-fluri-blue.svg)](https://www.dartdocs.org/documentation/fluri/latest/)

- [Changelog/Release Notes](https://github.com/Workiva/fluri/releases)
- [Examples/Usage](#examples-usage)
- [Minimum Dart SDK](#dart-sdk)
- [Versioning and Stability](#versioning-and-stability)
- [Development](#development)



## Examples/Usage

> Fluri is a fluent URI library for Dart built to make URI mutation easy.

The `dart:core.Uri` class provides an immutable representation of URIs, which
makes it difficult to incrementally build them or update them at a later time.
If you wanted to build a long URI from the individual pieces, you would do
something like this:

```dart
Uri uri = new Uri(
  scheme: 'https',
  host: 'example.com',
  path: 'path/to/resource'
);
```

If you later wanted to update the path and add a query parameter, you'd have to
do this:

```dart
uri = uri.replace(
  path: 'new/path',
  query: 'foo=true'
);
```

Now let's say you want update the query without losing what you already have:

```dart
Map query = new Map.from(uri.queryParameters);
query['bar'] = '10';
uri = uri.replace(queryParameters: query);
```

As you can see, incremental or fluent-style URI mutations become a hassle with
the core `Uri` class.

With fluri, the above interactions are easy:

```dart
import 'package:fluri/fluri.dart';

Fluri fluri = new Fluri()
  ..scheme = 'https'
  ..host = 'example.com'
  ..path = 'path/to/resource';

fluri
  ..path = 'new/path'
  ..query = 'foo=true';

fluri.updateQuery({'bar': '10'});
```

Additional methods like `appendToPath` and `setQueryParam` make it easy to
build on top of a base URL:

```dart
import 'package:fluri/fluri.dart';

Fluri base = new Fluri('https://example.com/base/');

Fluri fluri = new Fluri.from(base)
  ..appendToPath('path/to/resource')
  ..setQueryParam('count', '10');
```

Fluri also supports multi-value parameters. To access the query parameters as
`Map<String, List<String>>`, use `queryParametersAll` (just like the `Uri`
class):
                                              
```dart
var fluri = new Fluri('/resource?format=json&format=text');
print(fluri.queryParameters); // {'format': 'text'}
print(fluri.queryParametersAll); // {'format': ['json', 'text']}
```

To set a single query parameter to multiple values:

```dart
var fluri = new Fluri('/resource');
fluri.setQueryParam('format', ['json', 'text']);
print(fluri.queryParametersAll); // {'format': ['json', 'text']}
```

Using `setQueryParam` will always replace existing values:

```dart
var fluri = new Fluri('/resource');
fluri.setQueryParam('format', ['json', 'text']);
fluri.setQueryParam('format', ['binary', 'text']);
print(fluri.queryParametersAll); // {'format': ['binary', 'text']}
```

You can use the `queryParametersAll` setter to set the entire query with
multi-value param support:

```dart
var fluri = new Fluri('/resource');
fluri.queryParametersAll = {'format': ['json', 'text'], 'count': ['5']}
print(fluri.queryParametersAll); // {'format': ['json', 'text'], 'count': ['5']}
```

Again, if you need to preserve existing query parameters, you can use the
`updateQuery` method to do so. Set `mergeValues: true` and any values that you
provide will be merged with existing values:

```dart
var fluri = new Fluri('/resource?format=json');
fluri.updateQuery({'format': ['binary', 'text'], 'count': '5'}, mergeValues: true);
print(fluri.queryParametersAll); // {'format': ['binary', 'json', 'text'], 'count': ['5']}
```


### Dart SDK

As of version 1.2.0 of the `fluri` package, the minimum required Dart SDK
version is 1.15.0.


### Versioning and Stability

This library follows semver to the best of our interpretation of it. We want
this library to be a stable dependency that’s easy to keep current. A good
explanation of the versioning scheme that we intend to follow can be seen here
from React.js:

https://facebook.github.io/react/blog/2016/02/19/new-versioning-scheme.html

In short: our goal is for every major release to be backwards compatible with
the previous major version, giving consumers a lifespan of two major versions to
deal with deprecations.


## Development

This project leverages [the dart_dev package](https://github.com/Workiva/dart_dev)
for most of its tooling needs, including static analysis, code formatting,
running tests, collecting coverage, and serving examples. Check out the dart_dev
readme for more information.

## Changelog
# Changelog

## 1.2.0

- **Feature:** Support for multi-value parameters.

  See the [readme][https://github.com/Workiva/fluri/blob/master/README.md] for
  usage examples.

- **Dart SDK:** In order to support multi-value parameters, the minimum required
  Dart SDK version is now 1.15.0 since that is when the `queryParametersAll`
  field was added to the `Uri` class.

## 1.1.1

- **Bug Fix:** `FluriMixin` now defaults to an empty URI when `uri` is set to
  null.

## 1.1.0

**New Features:**

- `appendToPath(path)` - append a path literal to the current path.
- `addPathSegment(segment)` - add a single path segment to the current path.
- `setQueryParam(param, value)` - set a single query parameter.
- `Fluri.from(other)` - construct a `Fluri` instance from another.
- `Fluri.fromUri(uri)` - construct a `Fluri` instance from a `Uri` instance.

## 1.0.1
_No source changes in this release._

- Add code coverage reporting.
- Minor fixes and improvements to the readme.
- Code formatting improvements thanks to `dartfmt`.


## 1.0.0
- Initial version of Fluri: a fluent URI library for Dart built to make URI
  mutation easy.