exercism demo should not require login

[kytrinyx]

Demo should probably just download a demo into the current directory, in a subdirectory named exercism-demo or something like that, where each language is nested below it.

[kytrinyx]

@msgehard - the way I'm thinking of solving this is to create a guestConfig object, using os.Getwd to get the current working directory, then os.Mkdir to create the subdirectory, and sticking the full path to that subdirectory in the guestConfig as the project path.

Does that seem like a reasonable approach?

[mikegehard]

My thoughts on how I would go about solving it:

Option 1 (quick and dirty): Pass in an empty API key

assignments, err := exercism.FetchAssignments(config.Hostname, exercism.FetchEndpoints["demo"], "")

As long as the server doesn't check for the API key that should work.

Option 2 (a little more work but better in the long run):

Define a FetchDemoAssignments(hostname string) function that returns a slice of assignments.

You could then save them where ever you want in using:

err := exercism.SaveAssignment("some demo directory", a)

Here I need some way to get the demo directory. I'm not sure I'd use another object to store that since all we need is a way to calculate it and it will always be the same...I think.

Let me know if this jives with your thoughts from above. I think the only place we may differ is in the addition of a guest config object.

[kytrinyx]

Yeah, that sounds good.

I was trying to write a test for the DemoDirectory:

func TestDemoDir(t *testing.T) {
    path, err := ioutil.TempDir("", "")
    assert.Equal(t, "", path)
    assert.NoError(t, err)
    os.Chdir(path)

    demoDir, err := DemoDirectory()

    assert.Equal(t, demoDir, path+"/exercism-demo")
}

With something like this:

func DemoDirectory() (dir string, err error) {
    dir, err = os.Getwd()
    if err != nil {
        return
    }
    dir = dir + "/exercism-demo"
    return
}

The problem is that assertion fails because demoDir is "/var/folders/$GARBLE" and the test directory we created is "/private/var/folders/$GARBLE". Technically these are the same (/var is a symlink to /private/var).

Any idea how best to resolve that aside from just not having an automated test, that is)?

[kytrinyx]

I figured it out :) path/filepath#EvalSymlinks() FTW.

[kytrinyx]

UPDATE: I solved it the dirty way. I'll try to pair with someone to figure out the better way.

[mattetti]

Another way to write this code would be:

config, err := exercism.ConfigFromFile(exercism.HomeDir())
if err != nil {  
  if demoDir, err := exercism.DemoDirectory(); err != nil {
     fmt.Println(err)
     return
  }
  config = exercism.Config{
    Hostname: "http://exercism.io",
    ApiKey: "",
    ExercismDirectory: demoDir,
  }
}

[kytrinyx]

Thanks for all the comments, @mattetti. I'm going to leave the named returns, since that is a repository-wide choice at the moment. I'd love to hear more of the pros/cons if you have blog posts or musings lying around somewhere.

[mattetti]

To tell you the truth I mainly follow the advice @nf once gave me. Since Go
is all about being explicit, I'm surprised that the language design
included implicit returned values. My major problem with the implicit
returned values is that I'm not always sure what is being returned, it
forces me to go up to the function/method signature, read the names, go
back to the body, scan for the where the value is set before it's returned.

On Thu, Sep 26, 2013 at 10:48 PM, Katrina Owen notifications@github.comwrote:

Thanks for all the comments, @mattetti https://github.com/mattetti. I'm
going to leave the named returns, since that is a repository-wide choice at
the moment. I'd love to hear more of the pros/cons if you have blog posts
or musings lying around somewhere.

—
Reply to this email directly or view it on GitHubhttps://github.com//pull/11#issuecomment-25218992
.

[nf]

The "naked return" does have its readability drawbacks. It can also cause subtle errors where new variables shadow the return values in nested scopes. I tend to use it only in very short functions.

I mostly use named return values only when the names add necessary documentation. For instance, it's pretty clear what the return values of this function are, even without names:

func DemoDir() (string, error)

so I'd not used named return values here. But, say, this function decl

func Foo() (min, max int)

is a lot clearer than

func Foo() (int, int)

[mattetti]

thank you very much @nf!