added rebar, moved lager above erlsha2 in rebar.config to fix dependency...

hi :-) this fixes a dependency issue, erlsha2 needs lager to have been already built, otherwise you get the following:

==> erlsha2 (compile)
src/hmac.erl:none: error in parse transform 'lager_transform': {undef,
                                             [{lager_transform,
                                               parse_transform,
                                               [[{attribute,1,file,
                                                  {"src/hmac.erl",1}},
                                                 {attribute,10,module,hmac},
                                                 {attribute,11,export,
                                                  [{hexlify,1},
                                                   {hmac,2},
                                                   {hmac,4},
                                                   {hmac224,2},
                                                   {hmac256,2},
                                                   {hmac384,2},
                                                   {hmac512,2}]},
                                                 {function,27,hexlify,1,
                                                  [{clause,27,
                                                    [{var,27,'Binary'}],
                                                    [[{call,27,
                                                       {atom,27,is_binary},
                                                       [{var,27,'Binary'}]}]],
                                                    [{call,28,
                                                      {remote,28,
                                                       {atom,28,lists},
                                                       {atom,28,flatten}},
                                                      [{lc,28,
                                                        {call,28,
                                                         {remote,28,
                                                          {atom,28,io_lib},
                                                          {atom,28,format}},
                                                         [{string,28,
                                                           "~2.16.0B"},
                                                          {cons,28,
                                                           {var,28,'B'},
                                                           {nil,28}}]},
                                                        [{generate,29,
                                                          {var,29,'B'},
                                                          {call,29,
                                                           {atom,29,
                                                            binary_to_list},
                                                           [{var,29,
                                                             'Binary'}]}}]}]}]}]},
                                                 {function,38,hmac224,2,
                                                  [{clause,38,
                                                    [{var,38,'Key'},
                                                     {var,38,'Data'}],
                                                    [],
                                                    [{call,39,
                                                      {atom,39,hmac},
                                                      [{var,39,'Key'},
                                                       {var,39,'Data'},
                                                       {'fun',39,
                                                        {function,
                                                         {atom,39,erlsha2},
                                                         {atom,39,sha224},
                                                         {integer,39,1}}},
                                                       {integer,39,64}]}]}]},
                                                 {function,48,hmac256,2,
                                                  [{clause,48,
                                                    [{var,48,'Key'},
                                                     {var,48,'Data'}],
                                                    [],
                                                    [{call,49,
                                                      {atom,49,hmac},
                                                      [{var,49,'Key'},
                                                       {var,49,'Data'},
                                                       {'fun',49,
                                                        {function,
                                                         {atom,49,erlsha2},
                                                         {atom,49,sha256},
                                                         {integer,49,1}}},
                                                       {integer,49,64}]}]}]},
                                                 {function,58,hmac384,2,
                                                  [{clause,58,
                                                    [{var,58,'Key'},
                                                     {var,58,'Data'}],
                                                    [],
                                                    [{call,59,
                                                      {atom,59,hmac},
                                                      [{var,59,'Key'},
                                                       {var,59,'Data'},
                                                       {'fun',59,
                                                        {function,
                                                         {atom,59,erlsha2},
                                                         {atom,59,sha384},
                                                         {integer,59,1}}},
                                                       {integer,59,128}]}]}]},
                                                 {function,68,hmac512,2,
                                                  [{clause,68,
                                                    [{var,68,'Key'},
                                                     {var,68,'Data'}],
                                                    [],
                                                    [{call,69,
                                                      {atom,69,hmac},
                                                      [{var,69,'Key'},
                                                       {var,69,'Data'},
                                                       {'fun',69,
                                                        {function,
                                                         {atom,69,erlsha2},
                                                         {atom,69,sha512},
                                                         {integer,69,1}}},
                                                       {integer,69,128}]}]}]},
                                                 {function,78,hmac,2,
                                                  [{clause,78,
                                                    [{var,78,'Key'},
                                                     {var,78,'Data'}],
                                                    [],
                                                    [{call,79,
                                                      {remote,79,
                                                       {atom,79,crypto},
                                                       {atom,79,sha_mac}},
                                                      [{var,79,'Key'},
                                                       {var,79,'Data'}]}]}]},
                                                 {function,91,hmac,4,
                                                  [{clause,91,
                                                    [{var,91,'Key'},
                                                     {var,91,'Data'},
                                                     {var,91,'Hash'},
                                                     {var,91,'Blocksize'}],
                                                    [[{call,91,
                                                       {atom,91,is_list},
                                                       [{var,91,'Key'}]}]],
                                                    [{call,92,
                                                      {atom,92,hmac},
                                                      [{call,92,
                                                        {atom,92,
                                                         iolist_to_binary},
                                                        [{var,92,'Key'}]},
                                                       {var,92,'Data'},
                                                       {var,92,'Hash'},
                                                       {var,92,
                                                        'Blocksize'}]}]},
                                                   {clause,93,
                                                    [{var,93,'Key'},
                                                     {var,93,'Data'},
                                                     {var,93,'Hash'},
                                                     {var,93,'Blocksize'}],
                                                    [[{call,93,
                                                       {atom,93,is_list},
                                                       [{var,93,'Data'}]}]],
                                                    [{call,94,
                                                      {atom,94,hmac},
                                                      [{var,94,'Key'},
                                                       {call,94,
                                                        {atom,94,
                                                         iolist_to_binary},
                                                        [{var,94,'Data'}]},
                                                       {var,94,'Hash'},
                                                       {var,94,
                                                        'Blocksize'}]}]},
                                                   {clause,95,
                                                    [{var,95,'Key'},
                                                     {var,95,'Data'},
                                                     {var,95,'Hash'},
                                                     {var,95,'Blocksize'}],
                                                    [[{call,95,
                                                       {atom,95,is_binary},
                                                       [{var,95,'Key'}]},
                                                      {call,95,
                                                       {atom,95,is_binary},
                                                       [{var,95,'Data'}]}]],
                                                    [{match,96,
                                                      {var,96,'HashKey'},
                                                      {'case',97,
                                                       {op,97,'-',
                                                        {var,97,'Blocksize'},
                                                        {call,97,
                                                         {atom,97,byte_size},
                                                         [{var,97,'Key'}]}},
                                                       [{clause,98,
                                                         [{var,98,'X'}],
                                                         [[{op,98,'<',
                                                            {var,98,'X'},
                                                            {integer,98,0}}]],
                                                         [{match,99,
                                                           {var,99,
                                                            'KeyDigest'},
                                                           {call,99,
                                                            {var,99,'Hash'},
                                                            [{var,99,'Key'}]}},
                                                          {match,100,
                                                           {var,100,'Pad'},
                                                           {op,100,'-',
                                                            {var,100,
                                                             'Blocksize'},
                                                            {call,100,
                                                             {atom,100,
                                                              byte_size},
                                                             [{var,100,
                                                               'KeyDigest'}]}}},
                                                          {bin,101,
                                                           [{bin_element,101,
                                                             {var,101,
                                                              'KeyDigest'},
                                                             default,
                                                             [binary]},
                                                            {bin_element,101,
                                                             {integer,101,0},
                                                             {op,101,'*',
                                                              {var,101,'Pad'},
                                                              {integer,101,8}},
                                                             default}]}]},
                                                        {clause,102,
                                                         [{var,102,'X'}],
                                                         [[{op,102,'>',
                                                            {var,102,'X'},
                                                            {integer,102,0}}]],
                                                         [{bin,103,
                                                           [{bin_element,103,
                                                             {var,103,'Key'},
                                                             default,
                                                             [binary]},
                                                            {bin_element,103,
                                                             {integer,103,0},
                                                             {op,103,'*',
                                                              {var,103,'X'},
                                                              {integer,103,8}},
                                                             default}]}]},
                                                        {clause,104,
                                                         [{var,104,'X'}],
                                                         [[{op,104,'=:=',
                                                            {var,104,'X'},
                                                            {integer,104,0}}]],
                                                         [{var,105,'Key'}]}]}},
                                                     {match,107,
                                                      {var,107,'IPad'},
                                                      {call,107,
                                                       {remote,107,
                                                        {atom,107,binary},
                                                        {atom,107,copy}},
                                                       [{bin,107,
                                                         [{bin_element,107,
                                                           {integer,107,54},
                                                           default,default}]},
                                                        {var,107,
                                                         'Blocksize'}]}},
                                                     {match,108,
                                                      {var,108,'OPad'},
                                                      {call,108,
                                                       {remote,108,
                                                        {atom,108,binary},
                                                        {atom,108,copy}},
                                                       [{bin,108,
                                                         [{bin_element,108,
                                                           {integer,108,92},
                                                           default,default}]},
                                                        {var,108,
                                                         'Blocksize'}]}},
                                                     {match,109,
                                                      {var,109,'HVal'},
                                                      {call,109,
                                                       {var,109,'Hash'},
                                                       [{bin,109,
                                                         [{bin_element,109,
                                                           {call,109,
                                                            {remote,109,
                                                             {atom,109,crypto},
                                                             {atom,109,exor}},
                                                            [{var,109,
                                                              'HashKey'},
                                                             {var,109,
                                                              'IPad'}]},
                                                           default,
                                                           [binary]},
                                                          {bin_element,109,
                                                           {var,109,'Data'},
                                                           default,
                                                           [binary]}]}]}},
                                                     {call,110,
                                                      {var,110,'Hash'},
                                                      [{bin,110,
                                                        [{bin_element,110,
                                                          {call,110,
                                                           {remote,110,
                                                            {atom,110,crypto},
                                                            {atom,110,exor}},
                                                           [{var,110,
                                                             'HashKey'},
                                                            {var,110,'OPad'}]},
                                                          default,
                                                          [binary]},
                                                         {bin_element,110,
                                                          {var,110,'HVal'},
                                                          default,
                                                          [binary]}]}]}]}]},
                                                 {eof,111}],
                                                [{outdir,"ebin"},
                                                 debug_info,
                                                 {parse_transform,
                                                  lager_transform},
                                                 {i,"include"},
                                                 report_errors,
                                                 report_warnings]],
                                               []},
                                              {compile,
                                               '-foldl_transform/2-anonymous-2-',
                                               2,
                                               [{file,"compile.erl"},
                                                {line,847}]},
                                              {compile,foldl_transform,2,
                                               [{file,"compile.erl"},
                                                {line,849}]},
                                              {compile,
                                               '-internal_comp/4-anonymous-1-',
                                               2,
                                               [{file,"compile.erl"},
                                                {line,273}]},
                                              {compile,fold_comp,3,
                                               [{file,"compile.erl"},
                                                {line,291}]},
                                              {compile,internal_comp,4,
                                               [{file,"compile.erl"},
                                                {line,275}]},
                                              {compile,
                                               '-do_compile/2-anonymous-0-',2,
                                               [{file,"compile.erl"},
                                                {line,152}]}]}