Giter Site home page Giter Site logo

arquillian / arquillian.github.io Goto Github PK

View Code? Open in Web Editor NEW
78.0 17.0 146.0 635.27 MB

Arquillian website source (develop branch) and hosting (master branch). Baked with Awestruct.

Home Page: http://arquillian.org

License: Other

HTML 32.69% Ruby 24.09% Shell 3.89% JavaScript 16.20% Dockerfile 0.22% Haml 14.95% SCSS 7.96%

arquillian.github.io's Introduction

Ike Arquillian Website Source

This repository contains the source of the Arquillian website (hosted using github pages), to which the arquillian.org hostname resolves.

The website is built using Awestruct. The develop branch contains the unprocessed website source. From that content, Awestruct generates a static website under the _site directory. The website is published to the public site by pushing the contents of the _site directory to the master branch.

Setting Up

First and foremost clone this repository :) In order to be able to generate the whole site you will also need to create a GitHub token for command-line use. Follow this guide and put it in .github-auth file in thre root of the cloned directory (it’s already ignored by Git so you shouldn’t be worried about compromising it). Subsequent sections explain how to run Awesturct in Dockerized setup or Local setup.

Dockerized setup

The following instructions allow you to work on arquillian.org in the isolated Docker container while still being able to edit the content locally using your favorite editor. If you don’t have Docker installed please follow this guide first.

First step is to build the image based on Dockerfile included in the root folder of this repository. Simply execute following command.

docker build -t arquillian/blog .

This will create a Docker image tagged as arquillian/blog.

Once you have the image built you can start Docker container to generate Awestruct stire from within it. You can preview the site under http://localhost:4242 on Linux or http://<docker-ip>:4242 with boot2docker, where docker-ip can be retrieved via boot2docker ip.

docker run -it --rm --net=host -v $PWD:/home/dev/${PWD##*/} -p 4242:4242 arquillian/blog

This command will work from the root of your arquillian.org directory (as we mount the repository folder using -v $PWD:/home/dev/${PWD##*/}).

--net=host flag might not be needed, but in case when your website is not accessible from the host, according to this issue in Docker GitHub repo, this might be the solution.

Before you start Previewing the Site Locally there is one last command you need to execute from within running Docker container. You have to install the gems required for the whole machinery to kick in. From the root of your arquillian.org directory (which is now accessible from within the container) execute following command:

bundle install -j 10  // (1)
  1. In addition you can add --path ./.gems (or just use an alias install-gems) to install gems inside the folder where your git repository is. This will speed up subsequent runs of the container.

And you are ready to start writing!

Or…​ if you are brave enough, continue reading next section to learn how to set it up locally.

Important

If you run the container on a SELinux-enabled host (for example on Fedora) you need to change the SELinux label of the directory that contains the source code of your website to be able to modify it from inside of the container:

chcon -t svirt_sandbox_file_t -R $PWD

Local setup

You need to have Awestruct installed on your machine to preview the website locally. Awestruct is a available as Ruby gem in the GemCutter repository. You can install it into either a native Ruby or a JRuby installation. The instructions here will cover setting up Awestruct in both native Ruby and JRuby installation for Linux environment.

Begin by installing the package for Ruby and RubyGems.

Installing Ruby and RubyGems on Ubuntu

If you have Ubuntu, use this command to install Ruby and RubyGems:

$ sudo apt-get install rubygems

Ubuntu does not currently add the RubyGems bin directory to your path. Put the following files in your shell configuration file (.bashrc) and restart the shell.

$ export GEM_HOME=/var/lib/gems/1.8 \
export PATH=$PATH:$GEM_HOME/bin

Now the executables for any gem you install will be available on your path.

Installing JRuby on Ubuntu

It might happen that you will face similar problem while trying to install awestruct using Ruby on Ubuntu. In that case using JRuby as an alternative might solve it.

First, download and unpack latest stable version of JRuby: (The one available in Ubuntu repositories is too old and does not support Awestruct)

$ wget http://jruby.org.s3.amazonaws.com/downloads/1.6.7/jruby-bin-1.6.7.tar.gz \
tar -xzvf jruby-bin-1.6.7.tar.gz

Optionally, you can copy it to /usr/lib/jvm and create symbolic link for convenience:

$ sudo mv jruby-1.6.7/ /usr/lib/jvm \
cd /usr/lib/jvm/ \
sudo ln -s jruby-1.6.7/ jruby

Last step is adding JRuby to path (for instance in .bashrc)

$ export JRUBY_HOME=/usr/lib/jvm/jruby \
export PATH=``$JRUBY_HOME/bin:$PATH''

Also, make sure to unset GEM_HOME for your session or else JRuby will try to install gems into your system installation.

$ unset GEM_HOME

That’s it. Just install all required gems described in subsequent sections and you are ready to run awestruct backed by JRuby!

Note
Use jgem instead of sudo gem for this purpose.

Installing Ruby and RubyGems on Fedora

If you have Fedora, use this command to install Ruby and RubyGems:

$ sudo yum install ruby ruby-devel ruby-irb rubygems

Optionally, you can install RubyGems manually to use a newer version (was once a requirement for installing Awestruct, but has since been fixed):

$ wget -q http://production.cf.rubygems.org/rubygems/rubygems-1.8.15.tgz \
tar xzf rubygems-1.8.15.tgz \
cd rubygems-1.8.15 \
sudo ruby setup.rb

In Fedora, RubyGems properly links applications such as awestruct to /usr/bin when the corresponding gem is installed, so no need for messing with the PATH.

Installing the Awestruct Gem

Now you are ready to install awestruct. The remainder of the commands work on any Ruby installation. If you’re using JRuby, remember to use jgem instead of sudo gem.

Use this command to install the awestruct gem and its dependencies:

$ sudo gem install awestruct

If you get a compiler error when RedCloth is installing, use this command instead:

$ sudo gem install awestruct -- --with-cflags=\``-O2 -pipe -march=native -Wno-unused-but-set-variable\''

You’re all set!

If you’ve previously installed awestruct, make sure you have Awestruct >= 0.2.15. You can update it update it using this command:

$ sudo gem update awestruct
Important

If you’re using JRuby, you’ll need to update your RedCloth gem to support international characters. Follow these steps:

Additional Required Gems

As the website matures, more gems will be required. This section documents the required third-party gems not already installed by Awestruct.

Install these Gems using the sudo gem install command (or jgem install command for JRuby) as you did above.

  • rest-client

  • git

  • vpim

  • jruby-openssl (if using jruby)

  • rb-inotify (if using linux)

  • ri_cal

  • tzinfo

  • hpricot

  • RedCloth

Installing Awestruct and Required Gems using Bundler

Now there’s an even easier way to get setuFirst, make sure you have the Bundler gem installed:

$ sudo gem install bundler

Now Bundler can handle the rest of the setup automatically:

$ sudo bundle install

At this point, you are ready to pull down the site and run it.

Previewing the Site Locally

Now that you have awestruct installed, you can preview the website locally by running it in development mode. Development mode uses a file monitor to automatically update the site when you make a change to the source files.

To run the site, you first need the source code. Begin by cloning the website source code from git:

git clone git://github.com/arquillian/arquillian.github.com.git

Then, switch to the develop branch (the master branch holds the published site only):

git checkout develop

Run the following command to launch the preview server:

awestruct -d
Important
Currently when running awestruct in the preview mode some of the auto-generated pages (e.g. modules) are not generated. If you want to see them too please run full generation of _site folder first, as described below.

Visit the following page in your browser:

You’re now awestruct!

If you only want to generate once when you start the server, use this command:

awestruct --server -P development

Add the --force flag to either command to regenerate the site from scratch. You can also remove the _tmp and _site directories to clean the generated files.

Conventions

Haml is the preferred abstract HTML markup language.

Sass and Compass are the preferred CSS frameworks.

Source files are indented using 2 spaces. Haml files require the same indentation size throughout. Ruby hashes should have no leading or trailing spaces and options such be seperated by a comma followed by a space (e.g., {:href⇒'http://arquillian.org', title⇒'Arquillian Project Site'}).

Note: In a HAML document, if you use the equals seperator (=) rather than a greater than equals () in a hash key-value assignment, Awestruct will crash.

Page structure

  • #banner

    • h2#logo

    • #navigation

  • #main

    • #intro

      • .hgroup

        • h1

      • .aside

    • #content

      • .post

        • .header

          • h2.title

          • .byline

        • .body

        • .footer

    • #sidebar

  • #footer


  • #intro

  • #content

    • section#primary

    • aside

Writing a Blog Entry

Writing a blog entry is very easy. All you have to do is fill in a brief prolog at the top of the file, then just type your content. The rest is handled for you.

Filename

To write a blog entry, create a new textile document with the file extension .textile in the blog/ folder. The name of the file is important. It determines the date of the blog entry and the URL. The syntax is:

YYYY-MM-DD-URL.textile

You cannot use dots or spaces in the URL segment.

For example:

2011-10-02-announcing-arquillian-1-0.textile

Prolog

The prolog is a set of name/value pairs defined at the top of the file in between two lines containing three dashes. In this section you define the following metadata:

  • layout (always "blog")

  • title (use sentence capitalization)

  • author (use github id)

  • tags (array structure, limit to 5, use singular forms as in "release")

Here’s an example (refer to HTML output):

---
layout: blog
title: Ike is our hero
author: aslakknutsen
tags: [ announcements, ike ]
--- << only copy the hyphens and the lines of text between them

If you want the post to appear in the JBoss Central view in JBoss Tools, add jbosscentral to the list of tags.

Content

Below the prolog, you just type in textile format.

Code

Note
Please follow the JBoss Community syntax conventions when formatting the code (to ensure all posts look consistent).

To insert syntax highlighted code, followed by paragraph text, use the following syntax (refer to HTML output of this guide):

public class Alien {
    public String getName() {
        return "Ike";
    }
}

This sentence will appear below the code. The language is detected automatically.

You don’t normally need to use the prefix to enter a paragrah. However, it’s required after a code block to indicate to the parser that the code snippet has ended. If the content following the code is not paragraph text (for instance, a list item), use notextile. instead of p., but include one space at the end of the line.

If you are running awestruct in preview mode, you need to touch the blog/index.html.haml file to see the blog show up in the index (likely a bug).

Images

Images should be put in the images/blog/ folder. An image should be no more than 600px wide.

Writing a Release Note

Writing a release note is even easier than blog post. There is a template file created for this purpose blog/_github-release-template.textile.

Simply name your file using following convention [repository-name]-[versionId].textile (eg. arquillian-core-1.0.0.CR6.textile). Fill in the most important features which are part of this particular release.

Other things like JIRA tasks are picked up automatically.

If for some reason you are not able to see your release notes on blog/ aggregator page, perform following steps:

Delete where tag/release information is read from:

rm -rf _tmp/repos/[repo-that-contain-release]

Delete the overview from JIRA that contains all released versions:

rm -rf _tmp/jira/jira-ARQ.json

Then restart awestruct and everything should work nicely.

Writing a Guide

Writing a guide is much like writing a blog entry (and, as such, just as easy). You need to supply some prolog information, a header stating what the guide covers and content partitioned using level 3 (h3) headings. The rest is handled for you, including the table of contents and listing in the index.

Important
When committing a guide, put it in a commit by itself and use a commit message that describes to a reader what changed. Commit messages are used as the guide’s changelog.

Filename

To write a blog entry, create a new textile document with the file extension .textile in the guides/ folder. The name of the file will become the last path in the guide’s URL and thus should closely match the guide’s title. Since it’s part of the URL, the filename should not contain spaces.

Prolog

The prolog is a set of name/value pairs defined at the top of the file in between two lines containing three dashes. In this section you define the following metadata:

  • layout (always "guide")

  • title (use title capitalization)

  • authors (comma seperated list of original authors of the guide)

  • translators (comma seperated list, for translations only)

  • tags (comma seperated list)

  • guide_summary (summary text to be used in the guide index)

  • guide_group (numeric; 1 = beginner, 2 = intermediate, 3 = advanced)

  • guide_order (numeric weight; less is more)

Here’s an example (refer to HTML output):

layout: guide
title: Getting Started
authors: [Dan Allen]
tags: [cdi, weld, maven, forge, eclipse]
guide_summary: Learn how to add Arquillian to the test suite of your project and write your first Arquillian test.
guide_group: 1
guide_order: 10
--- << only copy the hyphens and the lines of text between them

Content

Below the prolog, you type in textile format. (Don’t use an h2. heading for the title, it will be inserted automatically.)

You should begin each guide with a summary that lays out what the guide covers. It should be regular paragraph text surrounding a list of topics.

The remainder of the content should be divided into level 3 (h3) headings. The heading title should be no more than 20 characters and use title capitalization.

Note
Currently, you cannot use acronyms in the heading of a guide section.

Code

Refer to the instruction for writing a blog entry to learn how to enter code.

Images

Images should be put in the images/guides/ folder.

Textile Extensions

You can add emoticons by immediately preceding any of the following smile symbols with tilde (~):

:)
   smile

;)
   wink

:S
   confused

:D
   happy

Here’s an example ~;)

Style Classes

.last
   Defines the last column, used to remove the margin & padding to the right

.first
   Defines the first of something, used to remove the margin & padding from the top

.bottom
   Defines the last paragraph, used to remove the margin & padding from the bottom

Resources

arquillian.github.io's People

Contributors

alrubinger avatar antoinesd avatar aslakknutsen avatar bartoszmajsak avatar bennetelli avatar bleathem avatar csadilek avatar csierra avatar dipak-pawar avatar ehsavoie avatar gastaldi avatar gpoul avatar graphitefriction avatar hantsy avatar hasalex avatar hemanik avatar jmnarloch avatar kenfinnigan avatar kpiwko avatar leathersole avatar lincolnthree avatar lordofthejars avatar matousjobanek avatar mojavelinux avatar myfear avatar nickarls avatar paulbakker avatar rafaelsakurai avatar tolis-e avatar vineetreynolds avatar

Stargazers

 avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar

Watchers

 avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar

arquillian.github.io's Issues

Support Modules from External Sources

Similar to our Arquillian org on github, we need to support auto generation of Arquillian modules located outside of our own organisation. e.g. TomEE / Mobicens

Possible fork repo under Arquillian.org to have a common lookup registry for the Extension or support multiple sources..

Add helper for determining the latest version of a module

Useful for keeping examples / text / snippets up to date.

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.jboss.arquillian</groupId>
            <artifactId>arquillian-bom</artifactId>
            <version>#{site.latest('arquillian-core')}</version>
            <scope>import</scope>
            <type>pom</type>
        </dependency>
    </dependencies>
</dependencyManagement>

Write guide for testing Ike@Cloud

Support for containers running in the cloud is in active development. Once there is something usable, we should write a tutorial for how to do testing in the cloud. To borrow some points made in a blog entry we found, perhaps we can highlight:

  • run integration tests alongside unit tests from an IDE without having to remember to start an external process
  • debug the application running in the server on demand, without having to mess with remote debuggers (or Maven voodoo)

Candidate target containers are OpenShift, CloudBees and/or GAE.

Enhance "Code" section with link to the github projects using Arquillian

We should make people aware that besides guides there are projects with quite sophisticated use cases. For instance I cannot easily find "arquillian-showcase" reference. This could be also used as "what's next" guide - when a user will finish all the guides we can point him to this repo :)

Besides that I think we can link other projects using Arquillian, namely Seam kitchensink or any others (which we can simply crawl in the automatic manner).

What do you think?

Auto-generate the guide TOC

Auto-generate the guide toc, either using hpricot during generation or using jQuery on the client side. Tie in the floating toc JavaScript to this list (since it depends on it anyway).

Create a presentations page

We are constantly asked about Arquillian slidedecks. This problem is best solved by creating a page that just lists everything we have. Likely this should get merged with the videos page to be something like "presentations".

Add Auto matching of Keywords in Guides

Purpose

  • Automate the linking processes for Internal and External resources
  • Overview of used projects in guide from jboss and others
  • Help promote the other projects
  • Help users find e.g. internal module info

How

In the simplest form this could be:

Map<Keyword, List<ResourceLink>> keywords;

a Awstruct Extension would scan the content of all site guides for matches. Found matches are registered in the Guide Keywords map and the keyword it self is marked in the content.

We can then in the GUI use this information in two ways:

  • Show a list in the side bar with 'referenced projects'
  • Mark the keyword in the content it self

Both of those 'links' could show matched ResourceLink's.

And then to the interesting part, how to build the keyword lists:

  • Extension to populate the Keywords based on our own Modules (e.g. Name, ContainerName)
  • Extension to read the JBoss.org project REST api
  • Manually added to a yaml file
  • ?

A match on "JBoss AS 7" could show links to:

  • The JBoss AS 7 Project Page on jboss.org
  • The JBoss AS 7 Arquillian Container Module page
  • ?

If done generically, the same could be used to replace manual linking to user names, jira issues...

List<Matcher> matchers;

List<ResourceLink> match(String content) {
  List<ResourceLink> matches = new ArrayList<>;
  for(Matcher matcher : matchers) {
    matches.addAll(matches.find(content));
  }
  return matches;
}

Create mockups of module overview page showing inception->zeta status

The purpose of the mockups is to find an intuitive way to show the status/age/evolution of a module as well as provide visual definition between the different module categories.

Module status/age might fall along the following timeline:

brilliant idea conceived in a bar->not released, but here are some code snippets-> in development->alpha->beta->I've joined a monastery, somebody save my code so I can save my soul!->final->zeta->ancient and dusty

Not only is there 'age' to consider (alpha, beta) but also 'activity' (brainstorming, in development, needs to be saved, active, lost and confused, archived)

Ideas to mock up include color coding, iconifying, tags, and list sorting within categories

The mockups may also include links/visual cues representing prompts/questions asking if a person is interested in this module idea/do they think it is a good idea, if they want to help create it, etc.

Let me know (i.e. brainstorm below):

  1. What 'ages' (in addition to alpha, beta, and final) need to be created
  2. What 'status' or 'activity' levels a module is at/experiencing (idea conceived after midnight?, looking for a partner to watch sunsets with?, archived?) that need to be created
  3. Questions/pokes such as 'this module is an idea, do you think it would be useful?' and 'this module has been abandoned by the side of the highway, don't you want to take it home with you?' that would be useful
  4. Any other ideas about information needed on the module overview page http://arquillian.org/modules/

Link Guide highlighted 'code' references to Reference doc

When we reference classes / annotations in e.g. Guides, we should link the reference to the Reference docs/JavaDoc

We can extract Class Level JavaDoc for API/SPI classes into a background and use as reference, with links to the full ref.

Example from Guide:

2. A static method annotated with *@Deployment* that returns a ShrinkWrap archive

Example from JavaDoc:

The @Deployment annotation is used to define which Methods are to be considered a deployment method, a method that returns either a Archive or Descriptor. 

A Deployment is to be considered your test isolation level... yatta yatta..

link:see full class reference

@deployment ref in the Guide could link to a modal window with the full Class Level JavaDocs (not as JavaDoc, but parsed from JavaDoc and formatted for the site)

Possible syntax:

ref_link:Deployment
ref_link:DeployableContainer

ref_link:core/DeployableContainer
ref_link:persistence/Cleanup

Write guide for creating test with library dependencies

Write a guide, perhaps a simple one, that covers how to write a test that has library dependencies. This is briefly covered at the end of the functional testing guide, but needs to be brought more to the forefront.

Consider the following points:

  • Cherry picking library classes and packages
  • Adding a library to a war
  • Adding a library to an ear (maybe)

Show Release Note Author and Git Tagger

We should display both the Release Notes Author (driving person behind the release) and the Release Git Tagger (person doing the release) in the Release notes. Currently we only show the Tagger.

Evaluate contributor list findability

Task parsed from initial site burn down wikipage.

Currently the contributor link is only accessible from the footer. Additional locations for the contributor content and/or links to the contributor page should be evaluated.

Awestruct Extension::Google+ -> Event

Using the Extension::Event stream, we can publish new events to our Google+ page.

g+ -> A new video was added: [link]
g+ -> A new guide was added: [link]

Add support for + notation alla Google+ in guides/blogs

We could extend textile to process + as a name lookup in our identity maps alla Google+ for Blog/Guides.

"We then hooked up with +Dan Allen and +Andrew Rubinger for a beer at BierCentral"

The + translation would do the lookup in identity and replace it with a link to the user profile

Awestruct Extension::Event

Should provide a 'API' that different Extensions can publish to that are considered events.

Currently we have Blogs, Release Notes, Guides, Videos(vimeo), Talks(lanyrd), Modules

The Extensions that generate the different 'object' can push Events, e.g:

  • New Video added at [link]
  • Guide X updated : Message
  • New Talk: W-JAX - Code with confidence

The Event Extension can output to a RSS feed, a global 'change' feed

Arquillian Cheat Sheet page

Create a page (tutorial or otherwise) to serve as an Arquillian Cheat Sheet. This page consists of the top 10 - 20 key tidbits of knowledge to arm yourself with to be more productive. They may change over time, and that's fine.

We are going for something like the Gnome Shell Cheat Sheet.

http://live.gnome.org/GnomeShell/CheatSheet

Create mockups of third content block and/or mini-features for home page

The home page currently has two blocks of content: a slide show block and a block containing 3 sections titled: featured nobel, latest news, and upcoming events.

A third block of content has been proposed.
This content block might also be divided into 3 sections (but this depends on what content we decide to put in it).

Proposed sections include:
Latest/best press from sources other than the Arquillian blog (from automated feed)
Recent slideshows or videos (could randomize each time a person hits the home page)
Highlighted feature (could randomize each time a person hits the home page)
Highlighted module (could randomize each time a person hits the home page)
Featured project/company that uses Arquillian and how they use it (this would lead to an interview/blog/article)
Release notes of most recent release of a module/extension/etc.

@mojavelinux has also proposed adding a mini-overview of Arquillian features to the home page
Below are links to pages that illustrate this concept:

Are there any additional ideas/categories of content that people think might be useful on the front page?
Any opinions on the categories already suggested?
Any suggestions/opinions about having a mini-features display on the homepage?

"How To Contribute" information

How to Contribute section on each module page based on a contribute template that can be feed the correct repository information etc for the specific module.

Possible How To Contribute Guide + dynamic Module listing

Gravatar id for module lead on module page is wrong

The gravatar links for blog author [1] and module lead [2] are different for the same identity.

The Blog is using page.author which is correctly pointing to Lukas, while the Module page has Lukas as name, but the Gravatar is pointing to csierra (last one in list?)

The Module page use page.component.lead.jboss_username as a lookup, which on the Warp component is null, but it has email and name?

A few components has leads of type email/name and not jboss_username/name. Had a quick look at the source data from Jira, and it all seems to look ok.

[1] http://arquillian.org/blog/2012/05/27/arquillian-extension-warp-1-0-0-Alpha1/
[2] http://arquillian.org/modules/warp-extension/

Testing Java Persistence: wrong beans.xml location

in this function there is an error, which leads to

ERROR org.jboss.arquillian.protocol.jmx.JMXTestRunner Failed: org.arquillian.example.GamePersistenceTest.shouldFindAllGamesUsingCriteriaApi: java.lang.NullPointerException

@deployment
public static Archive<?> createDeployment() {
return ShrinkWrap.create(WebArchive.class, "test.war")
.addPackage(Game.class.getPackage())
.addAsResource("test-persistence.xml", "META-INF/persistence.xml")
.addAsWebResource(EmptyAsset.INSTANCE, "beans.xml");
}

one need to change to

.addAsWebInfResource(EmptyAsset.INSTANCE, "beans.xml");

see: https://community.jboss.org/thread/175404

More detail in getting started guide summary

Be more specific about what tools they will use in the getting started guide. Specifically, mention that they'll be using Eclipse. Put a sample usage of NetBeans in the "rinse and repeat" guide, then add it to the summary.

Awestruct Extension::Facebook -> Event

Using the Extension::Event stream, we can publish new events to our Facebook wall/page.

facebook -> A new video was added: [link]
facebook -> A new guide was added: [link]

New name for Modules page

Modules doesn't adequately describe the content found on the Modules overview page http://arquillian.org/modules/

The following categories are hosted on the Modules page: Platforms, Container Adapters, Extensions, Test Runners, Tool Plugins

New names discussed by @aslakknutsen and @mojavelinux include:

overview
reference
releases
artifacts

(I know there are other suggestions buried in my email...I'll find them)

Does anyone else have any ideas?

Include sub-projects in slideshow

When 1.0 has been out for a bit, dukes choice is a bit old etc..

We can change the carousel to display the top level sub modules.

Arquillian Drone
Arquillian Warp
Arquillian Persistence

Module Name + Tag line + Logo/background

Create Contributor Profile

All references to People on the site should be linked/backed by a UserProfile.

The content of the UserProfile could be anything from any source. e.g.

  • MasterBranch integration showing other projects being worked on outside of Arquillian
  • StackOverFlow integration showing activity / status
  • Twitter, Github, Blog links
  • Auto fetch and understand local commits/metadata, e.g. Contributed French Translation of Guide X

Arquillian API: Publish a Container Overview API

Based on the Awestruct::Extensions::GitHub::Org, we have all the repository info for all the supported containers and versions.

We should publish this info into a Tools usable format, e.g. JSON. This could be consumed by the Forge or JBossTools Arquillian support.

arquillian.org/api/containers.json

[
  {
    name:  "JBoss AS 5 Remote",
    group_id: "org.jboss.arquillian.container",
    artifact_id: "arquillian-jbossas-remote-5",
    versions: ["1.0.0.CR1", "1.0.0.CR2"],
    download: {
       url: "http://vla/bla",
       artifact: {
         group_id: 'org.jboss.jbossas',
         artifact_id: "jboss-as-districtubtion"
       }
    },
    dependencies: [
      {
         group_id: 'org.jboss.client',
         artifact_id: "jboss-as-client"
       }
    ]
  },
  {
   ...
  }
]

Recommend Projects

  • React photo React

    A declarative, efficient, and flexible JavaScript library for building user interfaces.

  • Vue.js photo Vue.js

    🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.

  • Typescript photo Typescript

    TypeScript is a superset of JavaScript that compiles to clean JavaScript output.

  • TensorFlow photo TensorFlow

    An Open Source Machine Learning Framework for Everyone

  • Django photo Django

    The Web framework for perfectionists with deadlines.

  • D3 photo D3

    Bring data to life with SVG, Canvas and HTML. 📊📈🎉

Recommend Topics

  • javascript

    JavaScript (JS) is a lightweight interpreted programming language with first-class functions.

  • web

    Some thing interesting about web. New door for the world.

  • server

    A server is a program made to process requests and deliver data to clients.

  • Machine learning

    Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.

  • Game

    Some thing interesting about game, make everyone happy.

Recommend Org

  • Facebook photo Facebook

    We are working to build community through open source technology. NB: members must have two-factor auth.

  • Microsoft photo Microsoft

    Open source projects and samples from Microsoft.

  • Google photo Google

    Google ❤️ Open Source for everyone.

  • D3 photo D3

    Data-Driven Documents codes.